diff --git a/README.md b/README.md index 3b0d765..0e2abf8 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ The Spring Integration Extensions project provides extension modules for [Spring * [SMB][] Support * [Print][] Support * [Atmosphere][] Support ([Websockets][]) +* [XQuery][] Support ## Getting support @@ -123,4 +124,5 @@ The Spring Integration Extensions Framework is released under version 2.0 of the [SMB]: http://en.wikipedia.org/wiki/Server_Message_Block [Print]: http://docs.oracle.com/javase/6/docs/technotes/guides/jps/index.html [Atmosphere]: https://github.com/Atmosphere/atmosphere -[Websockets]: http://www.html5rocks.com/en/tutorials/websockets/basics/ \ No newline at end of file +[Websockets]: http://www.html5rocks.com/en/tutorials/websockets/basics/ +[XQuery]: http://en.wikipedia.org/wiki/XQuery \ No newline at end of file diff --git a/spring-integration-xquery/README.md b/spring-integration-xquery/README.md new file mode 100644 index 0000000..63827e8 --- /dev/null +++ b/spring-integration-xquery/README.md @@ -0,0 +1,170 @@ +Spring Integration XQuery Support +================================= + +# Overview + +**XQuery** is a query and functional programming language that is used to query over a collection of XML data. XQuery is a super-set of **XPath 2.0**. Therefore, if you are looking for *XPath 2.0* functionality, you may consider using the provided components as well. For more information on *XQuery*, please see: + +* http://en.wikipedia.org/wiki/XQuery +* http://en.wikipedia.org/wiki/XPath_2.0 + +The **XQuery API for Java** ([JSR225][]) is a specification for providing a common *XQuery API* to the Java programming language. The API can be used for *XML databases* as well as pure *XQuery processors*. For more information, please see: + +* http://en.wikipedia.org/wiki/XQuery_API_for_Java +* http://xqj.net/ +* http://xqj.net/javadoc/ + +Various products and libraries provide *XQuery* support. Below is a selection of available choices: + +## XML Databases + +* **BaseX** (BSD License) - http://basex.org/ +* **eXist** (GNU LGPL) - http://www.exist-db.org/ +* **MarkLogic** (Commercial License, Free Option) - http://developer.marklogic.com/express +* **Sedna** (Apache License, Version 2.0) - http://www.sedna.org/ + +## XQuery Processors + +* **Zorba** (Apache License, Version 2.0) - http://www.zorba-xquery.com/ +* **SAXON** (Mozilla Public License) - http://saxon.sourceforge.net/ + +*Zorba* is written in C++ but provides a Java API ([JSR225][]). *SAXON*, being a pure Java implementation, can be used as a normal Java library. Of all the available XQuery supporting options, *SAXON* is probably the the most widely used choice for Java developers. + +# Provided Spring Integration Components + +Currently, the *Spring Integration XQuery Module* provides the following components: + +* XQuery Router +* XQuery Transformer + +## Java Implementation + +The class *o.s.i.xquery.core.XQueryExecutor* is the backbone for all *XQuery* related operations within this Spring Integration module. Its corresponding test class is *o.s.i.xquery.core.AbstractXQueryExecutorTests* with the subclasses: + +* *o.s.i.xquery.core.SaxonXQueryExecutorTests* +* *o.s.i.xquery.core.SednaXQueryExecutorTests* + +Each of these sub-classes instantiates the *XQueryExecutor* with the corresponding implementations of the *javax.xml.xquery.[XQDataSource][]* interface. The *XQueryExecutor* provides a setter for specifying the [XQDataSource][] to use. If not explicitly specified, it will default to use *Saxon*, if available on the classpath. + +The XQuery Executor is tested using Saxon and Sedna. Furthermore, we provide the [Spring Integration XQuery Samples][] that additionally also cover *BaseX*. *BaseX* is not included in the actual Spring Integration module, as it conflicts with the *Saxon* jars. Both, the *Sedna* and the *BaseX* XML database need to be started and the datasource needs to connect to them. This is even true, if the XML being queried is not present in the database (as we typically provide it with the payload of the Spring Integration *Message*). + +See the class comments of *o.s.i.xquery.core.SednaXQueryExecutorTests* for instructions on starting the *Sedna* server and executing the tests using *Sedna*'s implementation. Additional information can also be found at: + +* http://xqj.net/ + +Of course, much more detailed information is also available on the respective product websites. + +## XML Namespace Support + +The Spring Integration XQuery components also provide XML Namespace support in order to simplify their configuration. + +### Routers + +#### With **xquery** sub element + + + + + + + + + +The configuration is pretty simple. The XQuery in this example is specified using the *xquery* sub-element. The query once executed will yield the names of the output channels. XQueries can have *named parameters* specified. In this case we have two named parameters: **name** and **class**. + +The value or the expression to find the value for these named parameters is specified using the *xquery-parameter* sub-element. This sub-element provides two possible ways to provide parameters. In the first parameter, the value of the **name** parameter is deduced using a SpEL expression. For the second parameter named **class**, a statically defined value is used. + +#### With **xquery** attribute + + + + + +The above config now specifies the *xquery* attribute to specify the query. It additionally has the *converter* and the *xq-datasource* attributes. The *converter* holds a reference to the bean which implements the `org.springframework.integration.xml.DefaultXmlPayloadConverter` interface. By default it uses `org.springframework.integration.xml.DefaultXmlPayloadConverter` Please note that this interface and the implementation is from **spring-integration-xml** project. The *xq-datasource* attribute holds a reference to a bean that implements the `javax.xml.xquery.XQDataSource` interface. By default it will use `net.sf.saxon.xqj.SaxonXQDataSource` implementation. + +#### With **xquery-file-resource** attribute + + + + + + +Instead of the nested *xquery* element or the *xquery* attribute, we provide the path to the resource that contains the xquery, typically a *.xq* file. + +Similar to the routers in the core module, the xquery routers accept the mapping subelement to provide an additional level of indirection and mapping from the obtained value(s) from xquery execution to the output channels. Thus, you can have the following subelement in the xquery router definition + + + + +### Transformers + +Similar to routers, transformers too support accepting the xquery as a child sub element, attribute or an attribute with the resource path to the *.xq* file. Since the definitions and meaning of the common attributes are similar to that of the router, we will not be explaining them again unless we have some attribute specific to transformers. + +#### With **xquery** subelement + + + + + + + + + +#### With **xquery** attribute + + + + +An additional attibute *format-output* is mentioned, the value could be *true* or *false*. It informs the transformer to format the output xml generated after transformation. + +#### With **xquery-file** attribute. + + + + +###Credits +We would like to thank **Ganesh Shetty** for his suggestion of inclusion of *XQuery* support in *Spring Integration*, giving the initial requirements and use cases for this module. We look forward for more support from the community for evaluating the libraries and provide their feedback. + +[JSR225]: http://jcp.org/aboutJava/communityprocess/final/jsr225/index.html +[xqj.net]: http://xqj.net/ +[XQDataSource]: http://xqj.net/javadoc/javax/xml/xquery/XQDataSource.html +[Spring Integration XQuery Samples]: https://github.com/SpringSource/spring-integration-samples/tree/master/basic/xquery diff --git a/spring-integration-xquery/pom.xml b/spring-integration-xquery/pom.xml new file mode 100644 index 0000000..288518a --- /dev/null +++ b/spring-integration-xquery/pom.xml @@ -0,0 +1,109 @@ + + + + 4.0.0 + org.springframework.integration + spring-integration-xquery + 1.0.0-SNAPSHOT + + + The Apache Software License, Version 2.0 + http://www.apache.org/licenses/LICENSE-2.0.txt + repo + + + + + 2.2.1 + + + + + + maven-compiler-plugin + + 1.6 + 1.6 + + + + maven-surefire-plugin + + + **/*Tests.java + + + **/*Abstract*.java + + + **/SednaXQueryExecutorTests.java + + + + + + + + + springsource-libs-milestone + Spring Framework Maven Milestone Repository + https://repo.springsource.org/libs-milestone + + + + + + org.springframework.integration + spring-integration-core + 2.2.0.M3 + + + + org.springframework.integration + spring-integration-xml + 2.2.0.M3 + + + + org.springframework.integration + spring-integration-test + 2.2.0.M3 + + + + javax.xml.xquery + xqj-api + 1.0 + + + + net.sf.saxon + Saxon-HE + 9.4 + optional + + + + net.xqj.sedna + sedna-xqj + 1.0.0 + optional + + + + com.xqj2 + xqj2 + 0.0.1 + optional + + + + junit + junit-dep + 4.10 + test + + + \ No newline at end of file diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/IntegrationXQueryNamespaceHandler.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/IntegrationXQueryNamespaceHandler.java new file mode 100644 index 0000000..6eeaac5 --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/IntegrationXQueryNamespaceHandler.java @@ -0,0 +1,37 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; + +import org.springframework.integration.config.xml.AbstractIntegrationNamespaceHandler; + +/** + * The namespace handler for the "int-xquery" namespace + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class IntegrationXQueryNamespaceHandler extends + AbstractIntegrationNamespaceHandler { + + /* (non-Javadoc) + * @see org.springframework.beans.factory.xml.NamespaceHandler#init() + */ + public void init() { + registerBeanDefinitionParser("xquery-router", new XQueryRouterParser()); + registerBeanDefinitionParser("xquery-transformer", new XQueryTransformerParser()); + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryParserUtils.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryParserUtils.java new file mode 100644 index 0000000..202785b --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryParserUtils.java @@ -0,0 +1,148 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; + +import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; +import org.springframework.beans.factory.support.ManagedList; +import org.springframework.core.io.ClassPathResource; +import org.springframework.core.io.FileSystemResource; +import org.springframework.core.io.Resource; +import org.springframework.integration.config.xml.IntegrationNamespaceUtils; +import org.springframework.integration.xquery.core.XQueryExecutor; +import org.springframework.integration.xquery.support.XQueryParameter; +import org.springframework.util.Assert; +import org.springframework.util.ResourceUtils; +import org.springframework.util.StringUtils; +import org.w3c.dom.Attr; +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +/** + * The common utility class for the XQuery components that will be performing the + * common operations used in the parsers like, creating the XQueryExecutor instance + * etc. + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryParserUtils { + + /** + * Create the instance of the {@link XQueryExecutor} + * @param element + * @return + */ + public static final AbstractBeanDefinition getXQueryExecutor(Element element) { + BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(XQueryExecutor.class); + IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "converter"); + IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "xq-datasource","xQDataSource"); + IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "format-output"); + NodeList list = element.getElementsByTagNameNS(element.getNamespaceURI(), "xquery"); + Attr xQueryAttribute = element.getAttributeNode("xquery"); + Attr xQueryResource = element.getAttributeNode("xquery-file-resource"); + + Assert.isTrue(!(xQueryAttribute != null && xQueryResource != null), + "Only one of xquery or xquery-file-resource may be specified"); + + Assert.isTrue(!(xQueryAttribute != null && list != null && list.getLength() > 0), + "At most one of the xquery attribute " + + "or the xquery child element should to be provided"); + + Assert.isTrue(!(xQueryResource != null && list != null && list.getLength() > 0), + "At most one of the xquery-file-resource attribute " + + "or the xquery child element should to be provided"); + + Assert.isTrue(xQueryResource != null || xQueryAttribute != null || (list != null && list.getLength() > 0), + "At least one of xquery, xquery-file-resource attributes or the xquery child element needs to be provided"); + + if(xQueryResource != null) { + //resource specified + String textContent = xQueryResource.getTextContent(); + Assert.isTrue(StringUtils.hasText(textContent),"Non empty, non null resource path should be provided"); + Resource resource; + if(textContent.startsWith(ResourceUtils.CLASSPATH_URL_PREFIX)) { + resource = new ClassPathResource(textContent.substring(ResourceUtils.CLASSPATH_URL_PREFIX.length())); + } + else if(textContent.startsWith(ResourceUtils.FILE_URL_PREFIX)) { + resource = new FileSystemResource(textContent.substring(ResourceUtils.FILE_URL_PREFIX.length())); + } + else { + //assuming its a classpath resource + resource = new ClassPathResource(textContent); + } + builder.addPropertyValue("xQueryFileResource", resource); + } + else { + //child element or attribute defined + String textContent; + if(xQueryAttribute == null) { + //child might be element specified + Assert.isTrue(list != null && list.getLength() == 1,"Maximum one xquery child node may be specified"); + textContent = list.item(0).getTextContent(); + } + else { + //xquery specified in the attribute + textContent = xQueryAttribute.getTextContent(); + } + if(StringUtils.hasText(textContent)) { + builder.addPropertyValue("xQuery", textContent.trim()); + } + } + + //lets get the parameter nodes + NodeList parameters = element.getElementsByTagNameNS(element.getNamespaceURI(), "xquery-parameter"); + if(parameters != null && parameters.getLength() > 0) { + ManagedList params = new ManagedList(); + for(int i = 0;i < parameters.getLength();i++) { + Node node = parameters.item(i); + NamedNodeMap attrs = node.getAttributes(); + Assert.isTrue(attrs.getLength() > 1, + "One of ref, value or expression should be present with the name attribute"); + Attr nameAttr = (Attr)attrs.getNamedItem("name"); + + //TODO No check for the mutually exclusivity of these attributes, needed? + + //create a new XQueryParameter instance + BeanDefinitionBuilder paramBuilder = + BeanDefinitionBuilder.genericBeanDefinition(XQueryParameter.class); + paramBuilder.addConstructorArgValue(nameAttr.getTextContent()); + Attr attr; + //add the value if present + if(attrs.getNamedItem("value") != null) { + attr = (Attr)attrs.getNamedItem("value"); + paramBuilder.addPropertyValue("parameterValue",attr.getTextContent()); + } + else if(attrs.getNamedItem("ref") != null) { + attr = (Attr)attrs.getNamedItem("ref"); + paramBuilder.addPropertyReference("parameterValue", attr.getTextContent()); + } + else if(attrs.getNamedItem("expression") != null) { + attr = (Attr)attrs.getNamedItem("expression"); + paramBuilder.addPropertyValue("expression", attr.getTextContent()); + } + params.add(paramBuilder.getBeanDefinition()); + } + builder.addPropertyValue("xQueryParameters", params); + } + + + return builder.getBeanDefinition(); + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryRouterParser.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryRouterParser.java new file mode 100644 index 0000000..d1bb16b --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryRouterParser.java @@ -0,0 +1,44 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; +import org.springframework.beans.factory.xml.ParserContext; +import org.springframework.integration.config.xml.AbstractRouterParser; +import org.springframework.integration.xquery.router.XQueryRouter; +import org.w3c.dom.Element; + +/** + * The parser for the XQuery router + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class XQueryRouterParser extends AbstractRouterParser { + + @Override + protected BeanDefinition doParseRouter(Element element, + ParserContext parserContext) { + BeanDefinitionBuilder routerBuilder = BeanDefinitionBuilder.genericBeanDefinition(XQueryRouter.class); + AbstractBeanDefinition executor = XQueryParserUtils.getXQueryExecutor(element); + routerBuilder.addPropertyValue("executor", executor); + return routerBuilder.getBeanDefinition(); + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParser.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParser.java new file mode 100644 index 0000000..0a67e63 --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParser.java @@ -0,0 +1,87 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; + +import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; +import org.springframework.beans.factory.xml.ParserContext; +import org.springframework.integration.config.xml.AbstractTransformerParser; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; +import org.w3c.dom.Element; +import org.w3c.dom.Node; + +/** + * The parser for the XQuery transformer component + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryTransformerParser extends AbstractTransformerParser { + + /* (non-Javadoc) + * @see org.springframework.integration.config.xml.AbstractTransformerParser#getTransformerClassName() + */ + @Override + protected String getTransformerClassName() { + return "org.springframework.integration.xquery.transformer.XQueryTransformer"; + } + + /* (non-Javadoc) + * @see org.springframework.integration.config.xml.AbstractTransformerParser#parseTransformer(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext, org.springframework.beans.factory.support.BeanDefinitionBuilder) + */ + @Override + protected void parseTransformer(Element element, + ParserContext parserContext, BeanDefinitionBuilder builder) { + AbstractBeanDefinition executor = XQueryParserUtils.getXQueryExecutor(element); + builder.addPropertyValue("executor", executor); + //Add the result type and the result class attributes + String resultType = element.getAttribute("result-type"); + boolean hasResultType = StringUtils.hasText(resultType); + String xqueryResultMapper = element.getAttribute("xquery-result-mapper"); + boolean hasResultMapper = StringUtils.hasText(xqueryResultMapper); + Assert.isTrue(!(hasResultType && hasResultMapper), + "Only one of result-type or xquery-result-mapper may be specified"); + if(hasResultType) { + Class type = null; + if("string".equalsIgnoreCase(resultType)) { + type = String.class; + } + else if("boolean".equalsIgnoreCase(resultType)) { + type = Boolean.class; + } + else if("number".equalsIgnoreCase(resultType)) { + type = Number.class; + } + else if("node".equalsIgnoreCase(resultType)) { + type = Node.class; + } + else { + try { + type = Class.forName(resultType); + } catch (ClassNotFoundException e) { + new IllegalArgumentException("Class " + resultType + " specified in result-type not found, " + + "have you provided the fully qualified name?",e); + } + } + builder.addPropertyValue("resultType", type); + } + else if(hasResultMapper) { + builder.addPropertyReference("resultMapper", xqueryResultMapper); + } + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/core/XQueryExecutor.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/core/XQueryExecutor.java new file mode 100644 index 0000000..471b21e --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/core/XQueryExecutor.java @@ -0,0 +1,491 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.core; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.QName; +import javax.xml.xquery.XQConnection; +import javax.xml.xquery.XQConstants; +import javax.xml.xquery.XQDataSource; +import javax.xml.xquery.XQException; +import javax.xml.xquery.XQPreparedExpression; +import javax.xml.xquery.XQResultSequence; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.springframework.beans.factory.BeanClassLoaderAware; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.core.io.Resource; +import org.springframework.integration.Message; +import org.springframework.integration.MessagingException; +import org.springframework.integration.xml.DefaultXmlPayloadConverter; +import org.springframework.integration.xml.XmlPayloadConverter; +import org.springframework.integration.xquery.support.AbstractXQueryResultMapper; +import org.springframework.integration.xquery.support.BooleanResultMapper; +import org.springframework.integration.xquery.support.NodeResultMapper; +import org.springframework.integration.xquery.support.NumberResultMapper; +import org.springframework.integration.xquery.support.StringResultMapper; +import org.springframework.integration.xquery.support.XQueryParameter; +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.springframework.integration.xquery.support.XQueryUtils; +import org.springframework.util.Assert; +import org.springframework.util.ClassUtils; +import org.springframework.util.StringUtils; +import org.w3c.dom.Node; + +/** + * The common logic for performing the common xquery operations would reside in this + * implementation. + * The class would be instantiated with the xquery to be executed and the parameters + * that would be used. It would return the result of the execution with the + * {@link Message} instance passed to one of its execute methods. + * Currently doesn't support advanced mapping techniques of mapping the resulting Node(s) + * to a custom object type + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class XQueryExecutor implements InitializingBean,BeanClassLoaderAware { + + + private static final String SAXON_XQ_DATASOURCE_CLASS = "net.sf.saxon.xqj.SaxonXQDataSource"; + + private final Log logger = LogFactory.getLog(XQueryExecutor.class); + + /** + * The payload converter + */ + private XmlPayloadConverter converter = new DefaultXmlPayloadConverter(); + + @SuppressWarnings("rawtypes") + private volatile Map resultMappers; + + private volatile boolean formatOutput; + + /** + * The xQuery that this Executor will execute + */ + private String xQuery; + + private XQDataSource xqDataSource; + + private Map xQueryParameterMap; + + //maintained internally and used for setting the values + private List xQueryParameters; + + //The resource to the XQuery's .xq file + private Resource xQueryFileResource; + + private String userName; + + private String password; + + private ClassLoader classLoader = ClassUtils.getDefaultClassLoader(); + + //TODO: Can we have a static xml resource which will be used always to execute the + //given XQuery as against the one sent in the payload. The default is to use the one in the + //payload unless one for static xml is provided + + @Override + public void afterPropertiesSet() { + if(resultMappers == null) { + resultMappers = new HashMap,XQueryResultMapper>(); + } + addDefaultMappers(); + + if(xqDataSource == null) { + xqDataSource = discoverXQDataSource();//default + } + if(xQuery == null) { + //perhaps resource specified + Assert.notNull(xQueryFileResource, "One of XQuery or the XQuery resource is mandatory"); + xQuery = XQueryUtils.readXQueryFromResource(xQueryFileResource); + } + + try { + XQConnection conn = getConnection(); + XQPreparedExpression expression = conn.prepareExpression(xQuery); + QName[] extParameters = expression.getAllExternalVariables(); + if(extParameters != null && extParameters.length > 0) { + xQueryParameters = new ArrayList(); + for(QName qName:extParameters) { + xQueryParameters.add(qName.getLocalPart()); + } + } + expression.close(); + conn.close(); + } catch (XQException e) { + throw new MessagingException("Caught Exception while opening a connection to the datasource", e); + } + + if(xQueryParameters != null) { + if (xQueryParameterMap == null) { + throw new MessagingException("Expecting " + xQueryParameters.size() + " parameters in the xquery, " + + "but none provided to the router"); + } + + //now check if all the parameter needed are present in the map + List missingParameters = new ArrayList(); + for(String xQueryParameter:xQueryParameters) { + if(!xQueryParameterMap.containsKey(xQueryParameter)) { + missingParameters.add(xQueryParameter); + } + } + + if(missingParameters.size() > 0) { + StringBuilder builder = new StringBuilder(); + builder.append("[").append("$").append(missingParameters.get(0)); + if(missingParameters.size() > 1) { + for(int i = 1;i < missingParameters.size();i++) { + builder.append(", ").append("$").append(missingParameters.get(i)); + } + } + builder.append("]"); + throw new MessagingException("Missing parameter(s) " + builder.toString()); + } + } + + + } + + + + public void setBeanClassLoader(ClassLoader classLoader) { + Assert.notNull(classLoader, "Non null class loader instance expected"); + this.classLoader = classLoader; + + } + + + /** + * The method that finds an implementation in the classpath for some well known + * providers. This will kick into action only if an {@link XQDataSource} is not + * explicitly provided by the user by invoking {@link XQueryExecutor#setXQDataSource(XQDataSource)} + * The method currently looks for Saxon's implementation only + * + * @return the instantiated {@link XQDataSource} + */ + private XQDataSource discoverXQDataSource() { + Object xqDataSource = null; + try { + if(ClassUtils.isPresent(SAXON_XQ_DATASOURCE_CLASS, classLoader)) { + xqDataSource = Class.forName(SAXON_XQ_DATASOURCE_CLASS).newInstance(); + } + //For now its just Saxon we will discover, we can add other implementations here later + } catch (Exception e) { + throw new MessagingException("Unable to discover/instantiate an XQDataSource, " + + "see nested exception for details", e); + } + Assert.notNull(xqDataSource, "No XQDataSource provided nor any known implementation discovered in the classpath"); + logger.info("Using \"" + xqDataSource.getClass() + "\" as the XQDataSource implementation"); + return (XQDataSource)xqDataSource; + } + + /** + * Gets the connection, uses userName and password if one is set + * @return + * @throws XQException + */ + private XQConnection getConnection() throws XQException { + XQConnection conn; + if(StringUtils.hasText(userName)) { + conn = xqDataSource.getConnection(userName,password); + } + else { + conn = xqDataSource.getConnection(); + } + return conn; + } + + /** + * There are some default mappers defined, those will be added if the user has not provided + * some implementations for them + */ + @SuppressWarnings("unchecked") + private void addDefaultMappers() { + if(!resultMappers.containsKey(String.class)) { + StringResultMapper mapper = new StringResultMapper(); + mapper.setFormatOutput(formatOutput); + resultMappers.put(String.class, mapper); + } + + if(!resultMappers.containsKey(Boolean.class)) { + BooleanResultMapper mapper = new BooleanResultMapper(); + mapper.setFormatOutput(formatOutput); + resultMappers.put(Boolean.class, mapper); + } + + if(!resultMappers.containsKey(Number.class)) { + NumberResultMapper mapper = new NumberResultMapper(); + mapper.setFormatOutput(formatOutput); + resultMappers.put(Number.class, mapper); + } + + if(!resultMappers.containsKey(Node.class)) { + NodeResultMapper mapper = new NodeResultMapper(); + mapper.setFormatOutput(formatOutput); + resultMappers.put(Node.class, mapper); + } + } + + /** + * Executes the XQuery for result and produce the result as a {@link List} of {@link String} + * @param message the source message that would be used to derive the values of the parameters + * + * @return The {@link List} of results + */ + public List executeForString(Message message) { + return execute(message,String.class); + } + + /** + * Executes the XQuery for result and produce the result as a {@link List} of {@link Boolean} + * @param message the source message that would be used to derive the values of the parameters + * + * @return The {@link List} of results + */ + public List executeForBoolean(Message message) { + return execute(message,Boolean.class); + } + + + /** + * Executes the XQuery for result and produce the result as a {@link List} of {@link Number} + * @param message the source message that would be used to derive the values of the parameters + * + * @return The {@link List} of results + */ + public List executeForNumber(Message message) { + return execute(message,Number.class); + } + + /** + * Executes the XQuery for result and produce the result as a {@link List} of {@link Node} + * @param message the source message that would be used to derive the values of the parameters + * + * @return The {@link List} of results + */ + public List executeForNode(Message message) { + return execute(message,Node.class); + } + + /** + * Execute the given XQuery and returns a {@link List} of the provided type + * @param + * @param message + * @param returnType + * @return + */ + @SuppressWarnings({ "unchecked"}) + public List execute(Message message,Class returnType) { + Assert.notNull(message,"Non null message expected"); + Assert.notNull(returnType,"Non null type expected"); + Assert.isTrue(resultMappers.containsKey(returnType),"No Result mapper found for the type " + returnType.getName()); + return execute(message, (XQueryResultMapper)resultMappers.get(returnType)); + } + + /** + * The method that executes the actual XQuery and uses the provided mapper + * to get the result that is returned. + * @param + * @param message + * @param mapper + * @return + */ + public List execute(Message message,XQueryResultMapper mapper) { + Node node = converter.convertToNode(message.getPayload()); + + if(node == null) { + return null; + } + + XQConnection connection = null; + XQPreparedExpression expression = null; + try { + connection = getConnection(); + expression = connection.prepareExpression(xQuery); + expression.bindNode(XQConstants.CONTEXT_ITEM, node, null); + + //bind the parameter values + if(xQueryParameters != null && xQueryParameters.size() > 0) { + //bind them one by one + for(String parameter:xQueryParameters) { + XQueryParameter xQueryParam = xQueryParameterMap.get(parameter); + //TODO: Check what possible values can be supported to be set here + //Accordingly do we need to set the third parameter for XQItemType + expression.bindObject(new QName(xQueryParam.getParameterName()), + xQueryParam.evaluate(message), null); + } + } + + XQResultSequence result = expression.executeQuery(); + return mapper.mapResults(result); + + } catch (XQException e) { + throw new MessagingException("Caught Exception while opening a connection to the datasource", e); + } finally { + try { + if(expression != null) { + expression.close(); + } + if(connection != null) { + connection.close(); + } + } catch (XQException e) { + logger.error("Caught Exception while closing the XQ expression.connection", e); + } + } + } + + /** + * Sets all the result mappers to be used by this executor. + * @param + * @param mappers + */ + @SuppressWarnings("rawtypes") + public void setResultMappers(Map, XQueryResultMapper> mappers) { + Assert.notNull(mappers); + this.resultMappers = new HashMap, XQueryResultMapper>(mappers); + //not iterate through them and set the format + for(Object mapper:resultMappers.values()) { + if(mapper instanceof AbstractXQueryResultMapper) { + ((AbstractXQueryResultMapper)mapper).setFormatOutput(formatOutput); + } + } + } + + /** + *Set the {@link XmlPayloadConverter} that would be used to convert the payload + * into the XML {@link Node} + * + * @param converter + */ + public void setConverter(XmlPayloadConverter converter) { + Assert.notNull(converter, "Provide a non null instance of XmlPayloadConverter"); + this.converter = converter; + } + + /** + * The XQuery string that would be evaluated to determine the channel names + * @param xQuery + */ + public void setXQuery(String xQuery) { + Assert.isTrue(xQueryFileResource == null, "Only one of XQuery resource file or XQuery may be specified"); + Assert.notNull(xQuery, "Provide a non null XQuery"); + this.xQuery = xQuery; + } + + /** + * Sets the XQuery's .xq file as the resource. The contents of this file will be read as xQuery + * + * @param xQueryFileResource + */ + public void setXQueryFileResource(Resource xQueryFileResource) { + Assert.isTrue(xQuery == null,"Only one of XQuery resource file or XQuery may be specified"); + this.xQueryFileResource = xQueryFileResource; + } + + /** + * Sets the {@link XQDataSource} + * @param xqDataSource + */ + public void setXQDataSource(XQDataSource xqDataSource) { + Assert.notNull(xqDataSource, "Provide a non null instance of the XQDatasource"); + this.xqDataSource = xqDataSource; + } + + + /** + * Sets the parameter map where the parameter name is the key and the + * {@link XQueryParameter} instance is the value + * + * @param xQueryParameterMap + */ + public void setXQueryParameterMap( + Map xQueryParameterMap) { + this.xQueryParameterMap = xQueryParameterMap; + } + + /** + * Convenience method to add a {@link XQueryParameter} to the map + * @param param + */ + public void addXQueryParameter(XQueryParameter param) { + if(xQueryParameterMap == null) { + xQueryParameterMap = new HashMap(); + } + xQueryParameterMap.put(param.getParameterName(), param); + } + + /** + * Convenience method that would be used to set the parameters in the parameter + * map. Any non conflicting parameters would be retained + * @param params + */ + public void setXQueryParameters(List params) { + if(params != null && params.size() > 0) { + if(xQueryParameterMap == null) + xQueryParameterMap = new HashMap(); + for(XQueryParameter param:params) { + xQueryParameterMap.put(param.getParameterName(), param); + } + } + } + + /** + * If the output result is an xml, the value of this parameter will determine + * if the output xml is to be formatted or not. By default, the output will + * not be formatted + * + * @param formatOutput + */ + public void setFormatOutput(boolean formatOutput) { + this.formatOutput = formatOutput; + } + + + + //TODO: Support date, dateTime data types + + + /** + * Sets the user name to be used while obtaining the connection. + * + */ + public void setUserName(String userName) { + Assert.hasText(userName, "Null or empty string provided as user name"); + this.userName = userName; + } + + /** + * Sets the password to be used for obtaining the connection + * The value if ignored if the userName is null + * + * @param password + */ + public void setPassword(String password) { + Assert.notNull(password, "Null password provided"); + //Can password be empty string? + this.password = password; + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/router/XQueryRouter.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/router/XQueryRouter.java new file mode 100644 index 0000000..d05397a --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/router/XQueryRouter.java @@ -0,0 +1,84 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.router; + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.integration.Message; +import org.springframework.integration.router.AbstractMappingMessageRouter; +import org.springframework.integration.xquery.core.XQueryExecutor; +import org.springframework.util.Assert; + +/** + * The message router that will evaluate the provided XQuery on the xml to determine the channel(s) + * to which the message will be routed + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryRouter extends AbstractMappingMessageRouter { + + private XQueryExecutor executor; + + private Class resultType; + + @Override + public void onInit() { + super.onInit(); + Assert.notNull(executor,"No XQueryExecutor instance provided"); + if(resultType == null) { + resultType = String.class; + } + } + + /* (non-Javadoc) + * @see org.springframework.integration.router.AbstractMappingMessageRouter#getChannelKeys(org.springframework.integration.Message) + */ + @Override + protected List getChannelKeys(Message message) { + List channelKeys = null; + //Accept the key types in this class and then execute the appropriate method + channelKeys = new ArrayList(executor.execute(message, resultType)); + return channelKeys; + } + + + + @Override + public String getComponentType() { + return "int-xml:xquery-router"; + } + + /** + * Sets the executor to be used for executing the XQueries + * @param executor + */ + public void setExecutor(XQueryExecutor executor) { + Assert.notNull(executor,"Provide a non null implementation of the executor"); + this.executor = executor; + } + + /** + * Determines the type of the object that would returned in the {@link List} returned + * from getChannelKeys method. If non specified, {@link String} is assumed. + * @param resultType + */ + public void setResultType(Class resultType) { + this.resultType = resultType; + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/AbstractXQueryResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/AbstractXQueryResultMapper.java new file mode 100644 index 0000000..8d8d9bb --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/AbstractXQueryResultMapper.java @@ -0,0 +1,289 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import static javax.xml.xquery.XQItemType.XQBASETYPE_BOOLEAN; +import static javax.xml.xquery.XQItemType.XQBASETYPE_DECIMAL; +import static javax.xml.xquery.XQItemType.XQBASETYPE_DOUBLE; +import static javax.xml.xquery.XQItemType.XQBASETYPE_FLOAT; +import static javax.xml.xquery.XQItemType.XQBASETYPE_INT; +import static javax.xml.xquery.XQItemType.XQBASETYPE_INTEGER; +import static javax.xml.xquery.XQItemType.XQBASETYPE_LONG; +import static javax.xml.xquery.XQItemType.XQBASETYPE_NEGATIVE_INTEGER; +import static javax.xml.xquery.XQItemType.XQBASETYPE_NONNEGATIVE_INTEGER; +import static javax.xml.xquery.XQItemType.XQBASETYPE_NONPOSITIVE_INTEGER; +import static javax.xml.xquery.XQItemType.XQBASETYPE_POSITIVE_INTEGER; +import static javax.xml.xquery.XQItemType.XQBASETYPE_SHORT; +import static javax.xml.xquery.XQItemType.XQBASETYPE_STRING; +import static javax.xml.xquery.XQItemType.XQBASETYPE_UNSIGNED_INT; +import static javax.xml.xquery.XQItemType.XQBASETYPE_UNSIGNED_LONG; +import static javax.xml.xquery.XQItemType.XQBASETYPE_UNSIGNED_SHORT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_ATTRIBUTE; +import static javax.xml.xquery.XQItemType.XQITEMKIND_COMMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_DOCUMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_DOCUMENT_ELEMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_ELEMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_NODE; +import static javax.xml.xquery.XQItemType.XQITEMKIND_PI; +import static javax.xml.xquery.XQItemType.XQITEMKIND_SCHEMA_ATTRIBUTE; +import static javax.xml.xquery.XQItemType.XQITEMKIND_SCHEMA_ELEMENT; +import static javax.xml.xquery.XQItemType.XQITEMKIND_TEXT; + +import java.io.StringWriter; +import java.math.BigInteger; + +import javax.xml.transform.OutputKeys; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerConfigurationException; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.TransformerFactoryConfigurationError; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; +import javax.xml.xquery.XQException; +import javax.xml.xquery.XQItemType; +import javax.xml.xquery.XQResultSequence; + +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.springframework.util.StringUtils; +import org.w3c.dom.Attr; +import org.w3c.dom.Node; + +/** + * The absract base class for {@link XQueryResultMapper} implementations + * @author Amol Nayak + * @since 2.2 + * + */ +public abstract class AbstractXQueryResultMapper implements XQueryResultMapper { + + protected volatile boolean formatOutput; + /** + * The getBaseType method throws an exception if the item kind is of some specific types + * This method will be used to check if the getBaseType method can be invoked or not + * on the given element + * + * + * @param type + * @return + */ + protected boolean shouldSkipBaseType(XQItemType type) { + return isNodeType(type); + } + + /** + * The method checks if the given type is a numeric field and returns an appropriate implementation + * of the {@link Number} + * + * @param type + * @param result + * @return the appropriate {@link Number} implementation or null if cannot be converted to number + */ + protected Number convertToNumber(XQItemType type,XQResultSequence result) throws XQException { + boolean skipBaseTypes = shouldSkipBaseType(type); + Number value = null; + if(!skipBaseTypes) { + int baseType = type.getBaseType(); + if(baseType == XQBASETYPE_DOUBLE) { + value = Double.valueOf(result.getDouble()); + + } + else if(baseType == XQBASETYPE_FLOAT) { + value = Float.valueOf(result.getFloat()); + } + else if(baseType == XQBASETYPE_DECIMAL) { + value = Double.valueOf(result.getAtomicValue()); + //TODO: Should DECIMAL be BigDecimal? + } + + else if(baseType == XQBASETYPE_INT + || baseType == XQBASETYPE_NEGATIVE_INTEGER + || baseType == XQBASETYPE_POSITIVE_INTEGER + || baseType == XQBASETYPE_NONNEGATIVE_INTEGER + || baseType == XQBASETYPE_NONPOSITIVE_INTEGER + || baseType == XQBASETYPE_UNSIGNED_INT) { + value = Integer.valueOf(result.getInt()); + } + else if(baseType == XQBASETYPE_INTEGER) { + value = BigInteger.valueOf(result.getInt()); + } + else if(baseType == XQBASETYPE_LONG + || baseType == XQBASETYPE_UNSIGNED_LONG) { + value = Long.valueOf(result.getLong()); + } + else if(baseType == XQBASETYPE_SHORT + || baseType == XQBASETYPE_UNSIGNED_SHORT) { + value = Short.valueOf(result.getShort()); + } + else if(baseType == XQBASETYPE_STRING) { + String strValue = result.getAtomicValue(); + value = convertStringToNumber(strValue); + } + } + else if(XQITEMKIND_TEXT == type.getItemKind()) { + String textContent = result.getNode().getTextContent(); + value = convertStringToNumber(textContent); + } + else if(XQITEMKIND_ATTRIBUTE == type.getItemKind()) { + String textContent = ((Attr)result.getNode()).getValue(); + value = convertStringToNumber(textContent); + } + + return value; + } + + /**Helper method that will be used to convert a String value to Number + * @param value + * @param strValue + * @return + */ + private Number convertStringToNumber(String strValue) { + Number value = null; + try { + if(StringUtils.hasText(strValue)) { + if(strValue.indexOf(".") > 0) { + value = Double.valueOf(strValue); + } + else { + value = Long.valueOf(strValue); + } + } + } catch(NumberFormatException ne) { + value = null; + } + return value; + } + + /** + * Gets the given text content as String if the type is a string base type + * @param type + * @param result + * @return + */ + protected String convertToString(XQItemType type,XQResultSequence result) throws XQException { + boolean skipBaseTypes = shouldSkipBaseType(type); + String value = null; + if(!skipBaseTypes) { + int baseType = type.getBaseType(); + if(baseType == XQBASETYPE_STRING) { + value = result.getAtomicValue(); + } + } + else if(XQITEMKIND_TEXT == type.getItemKind()) { + value = result.getNode().getTextContent(); + } + else if(XQITEMKIND_ATTRIBUTE == type.getItemKind()) { + value = ((Attr)result.getNode()).getValue(); + } + return value; + } + + /** + * Checks the data type of the string and converts to boolean if applicable. + * The types have to be either boolean or string. For a string value, + * the returned value is same as Boolean.valueOf(strValue) + * + * @param type + * @param result + * @return + */ + protected Boolean convertToBoolean(XQItemType type,XQResultSequence result) throws XQException { + boolean skipBaseTypes = shouldSkipBaseType(type); + Boolean value = null; + if(!skipBaseTypes) { + if(type.getBaseType() == XQBASETYPE_BOOLEAN) { + value = Boolean.valueOf(result.getBoolean()); + } + else if(type.getBaseType() == XQBASETYPE_STRING) { + value = Boolean.valueOf(result.getAtomicValue()); + } + } + else if(XQITEMKIND_TEXT == type.getItemKind()) { + String textContent = result.getNode().getTextContent(); + value = Boolean.valueOf(textContent); + } + else if(XQITEMKIND_ATTRIBUTE == type.getItemKind()) { + String textContent = ((Attr)result.getNode()).getValue(); + value = Boolean.valueOf(textContent); + } + return value; + } + + /** + * Returns true if the given type if for a valid node type + * @param type + * @return + */ + protected boolean isNodeType(XQItemType type) { + int itemKind = type.getItemKind(); + return ( + itemKind == XQITEMKIND_ATTRIBUTE + || + itemKind == XQITEMKIND_COMMENT + || + itemKind == XQITEMKIND_DOCUMENT + || + itemKind == XQITEMKIND_DOCUMENT_ELEMENT + || + itemKind == XQITEMKIND_DOCUMENT_SCHEMA_ELEMENT + || + itemKind == XQITEMKIND_ELEMENT + || + itemKind == XQITEMKIND_NODE + || + itemKind == XQITEMKIND_PI + || + itemKind == XQITEMKIND_SCHEMA_ATTRIBUTE + || + itemKind == XQITEMKIND_SCHEMA_ELEMENT + || + itemKind == XQITEMKIND_TEXT + ); + } + + /**Transforms the given {@link Node} to a String + * @param n + * @return + * @throws TransformerConfigurationException + * @throws TransformerFactoryConfigurationError + * @throws TransformerException + */ + protected String transformNodeToString(Node n) + throws TransformerConfigurationException, + TransformerFactoryConfigurationError, TransformerException { + String value; + StringWriter writer = new StringWriter(); + Transformer transformer = TransformerFactory.newInstance().newTransformer(); + if(formatOutput) + transformer.setOutputProperty(OutputKeys.INDENT, "yes"); + transformer.transform( new DOMSource(n), new StreamResult(writer)); + value = writer.toString(); + return value; + } + + /** + * If the output result is an xml, the value of this parameter will determine + * if the output xml is to be formatted or not. By default, the output will + * not be formatted + * + * @param formatOutput + */ + public void setFormatOutput(boolean formatOutput) { + this.formatOutput = formatOutput; + } + +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/BooleanResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/BooleanResultMapper.java new file mode 100644 index 0000000..f7ec562 --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/BooleanResultMapper.java @@ -0,0 +1,59 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.ArrayList; +import java.util.List; + +import javax.xml.xquery.XQItemType; +import javax.xml.xquery.XQResultSequence; + +import org.springframework.integration.MessagingException; +import org.w3c.dom.Node; + +/** + * The Result mapper implementation that maps the {@link XQResultSequence} to {@link Boolean} + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class BooleanResultMapper extends AbstractXQueryResultMapper { + + public List mapResults(XQResultSequence result) { + List results = new ArrayList(); + try { + //check for boolean or string type and convert it accordingly, if a node then get it's text + //content and convert to boolean + while(result.next()) { + XQItemType type = result.getItemType(); + Boolean value = convertToBoolean(type, result); + if(value == null) { + if(isNodeType(type)) { + Node n = result.getNode(); + value = Boolean.valueOf(transformNodeToString(n)); + } + } + results.add(value); + } + } catch (Exception e) { + throw new MessagingException("Caught Exception while mapping the result sequence to string",e); + } + return results; + } + +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NodeResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NodeResultMapper.java new file mode 100644 index 0000000..8c38f0b --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NodeResultMapper.java @@ -0,0 +1,52 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.ArrayList; +import java.util.List; + +import javax.xml.xquery.XQItemType; +import javax.xml.xquery.XQResultSequence; + +import org.springframework.integration.MessagingException; +import org.w3c.dom.Node; + +/** + * The Result mapper implementation that maps the {@link XQResultSequence} to {@link Node} + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class NodeResultMapper extends AbstractXQueryResultMapper { + + public List mapResults(XQResultSequence result) { + List results = new ArrayList(); + try { + while(result.next()) { + XQItemType type = result.getItemType(); + if(isNodeType(type)) { + Node n = result.getNode(); + results.add(n); + } + } + } catch (Exception e) { + throw new MessagingException("Caught Exception while mapping the result sequence to string",e); + } + return results; + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NumberResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NumberResultMapper.java new file mode 100644 index 0000000..238185b --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/NumberResultMapper.java @@ -0,0 +1,67 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.ArrayList; +import java.util.List; + +import javax.xml.xquery.XQItemType; +import javax.xml.xquery.XQResultSequence; + +import org.springframework.integration.MessagingException; +import org.springframework.util.StringUtils; +import org.w3c.dom.Node; + +/** + * The Result mapper implementation that maps the {@link XQResultSequence} to {@link Number} + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class NumberResultMapper extends AbstractXQueryResultMapper { + + public List mapResults(XQResultSequence result) { + List results = new ArrayList(); + try { + while(result.next()) { + + XQItemType type = result.getItemType(); + Number value = convertToNumber(type, result); + if(value == null) { + if(isNodeType(type)) { + Node n = result.getNode(); + String strValue = transformNodeToString(n); + if(StringUtils.hasText(strValue)) { + if(strValue.indexOf(".") > 0) { + value = Double.valueOf(strValue); + } + else { + value = Long.valueOf(strValue); + } + } + } + } + results.add(value); + } + } catch (Exception e) { + throw new MessagingException("Caught Exception while mapping the result sequence to string",e); + } + return results; + } + +} \ No newline at end of file diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/StringResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/StringResultMapper.java new file mode 100644 index 0000000..6014dfa --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/StringResultMapper.java @@ -0,0 +1,69 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.ArrayList; +import java.util.List; + +import javax.xml.xquery.XQItemType; +import javax.xml.xquery.XQResultSequence; + +import org.springframework.integration.MessagingException; +import org.w3c.dom.Node; + +/** + * The Result mapper implementation that maps the {@link XQResultSequence} to {@link String} + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class StringResultMapper extends AbstractXQueryResultMapper { + + public List mapResults(XQResultSequence result) { + List results = new ArrayList(); + try { + while(result.next()) { + XQItemType type = result.getItemType(); + String value = convertToString(type, result); + if(value == null) { + Number number = convertToNumber(type, result); + if(number == null) { + Boolean boolValue = convertToBoolean(type, result); + if(boolValue == null) { + if(isNodeType(type)) { + Node n = result.getNode(); + value = transformNodeToString(n); + } + } + else { + value = boolValue.toString(); + } + } + else { + value = number.toString(); + } + } + results.add(value); + + } + } catch (Exception e) { + throw new MessagingException("Caught Exception while mapping the result sequence to string",e); + } + return results; + } +} \ No newline at end of file diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryParameter.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryParameter.java new file mode 100644 index 0000000..0d5fd78 --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryParameter.java @@ -0,0 +1,134 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import org.springframework.expression.Expression; +import org.springframework.expression.spel.standard.SpelExpressionParser; +import org.springframework.integration.Message; +import org.springframework.integration.handler.ExpressionEvaluatingMessageProcessor; +import org.springframework.util.Assert; +import org.springframework.util.StringUtils; + +/** + * The class that represents the XQuery parameter provided. It is also responsible + * for the evaluation and returning the corresponding value against the given {@link Message} + * instance + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryParameter { + + private final String parameterName; + private volatile Object parameterValue; + private volatile String expression; + private volatile boolean isValueSet; + //Will be used only when an expression is set + private volatile ExpressionEvaluatingMessageProcessor messageProcessor; + + /** + * The default no argument constructor + */ + public XQueryParameter(String parameterName) { + Assert.hasText(parameterName, "Non null non empty String value expected for parameter name"); + this.parameterName = parameterName; + } + /** + * The constructor that takes the parameter name and a static parameter value + * + * @param parameterName + * @param parameterValue + */ + public XQueryParameter(String parameterName, Object parameterValue) { + this(parameterName); + Assert.notNull(parameterValue, "Parameter value provided is null"); + this.parameterValue = parameterValue; + isValueSet = true; + } + + /** + * The constructor that takes the parameter name and the expression that would + * be evaluated to get the value of the parameter + * @param parameterName + * @param expression + */ + public XQueryParameter(String parameterName, String expression) { + this(parameterName); + Assert.isTrue(StringUtils.hasText(expression), "Non null non empty String value expected for expression"); + setExpression(expression); + } + + + /** + * Gets the parameter name of this instance + * @return + */ + public String getParameterName() { + return parameterName; + } + + + /** + * Sets the parameter value, this is mutually exclusive with the expression + * @param parameterValue + */ + public void setParameterValue(Object parameterValue) { + Assert.isTrue(!StringUtils.hasText(expression), "The parameter value and expression are mutually " + + "exclusive, parameter expression already set"); + Assert.notNull(parameterValue, "Null parameter value provided"); + this.parameterValue = parameterValue; + isValueSet = true; + } + + + /** + * Sets the expression that would be evaluated to get the parameter value + * @param expression + */ + public void setExpression(String expression) { + Assert.isTrue(parameterValue == null, "The parameter value and expression are mutually exclusive" + + ", parameter value already set"); + Assert.isTrue(!StringUtils.hasText(this.expression), "Expression string is already set once, cannot reset it"); + Assert.hasText(expression, "Please provide a non null, non empty expression string"); + this.expression = expression; + isValueSet = false; + SpelExpressionParser parser = new SpelExpressionParser(); + Expression expr = parser.parseExpression(expression); + messageProcessor = new ExpressionEvaluatingMessageProcessor(expr); + } + + /** + * Evaluates the given message against the provided expression if one is set + * else, returns the static value provided. If none of the static value or + * expression are provided. The value returned is null. + * @param message + * @return + */ + public Object evaluate(Message message) { + if(isValueSet) { + return parameterValue; + } + else { + if(messageProcessor != null) { + return messageProcessor.processMessage(message); + } + else { + return null; + } + } + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryResultMapper.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryResultMapper.java new file mode 100644 index 0000000..948a8ee --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryResultMapper.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.List; + +import javax.xml.xquery.XQResultSequence; + +/** + * The strategy interface that will be used to map the {@link XQResultSequence} + * returned by XQuery execution to a List of the specified type + * + * @author Amol Nayak + * @since 2.2 + * + */ +public interface XQueryResultMapper { + + /** + * Maps the results from the {@link XQResultSequence} to a {@link List} of a specific type + * @param result + * @return + */ + List mapResults(XQResultSequence result); +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryUtils.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryUtils.java new file mode 100644 index 0000000..4c2ac56 --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/support/XQueryUtils.java @@ -0,0 +1,69 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.URL; + +import org.springframework.core.io.Resource; +import org.springframework.integration.MessagingException; +import org.springframework.util.Assert; + +/** + * The common utility class that is used to perform all common operations + * amongst XQuery modules. To contain all common operations that would be used + * by the router, transformer etc along with all the parsers for these components + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class XQueryUtils { + + /** + * Reads the XQuery string from the resource file specified + * + * @param resource the {@link Resource} instance of the file that contains the XQuery + * currently only classpath and file resources are supported + * + * @return the XQuery string from the resource specified + */ + public static String readXQueryFromResource(Resource resource) { + Assert.notNull(resource, "null resource provided"); + Assert.isTrue(resource.exists(), "Provided XQuery resource does not exist"); + Assert.isTrue(resource.isReadable(), "Provided XQuery resource is not readable"); + try { + URL url = resource.getURL(); + InputStream inStream = url.openStream(); + BufferedReader reader = new BufferedReader(new InputStreamReader(inStream)); + String line = reader.readLine(); + StringBuilder builder = new StringBuilder(); + while(line != null) { + builder.append(line).append("\n"); + line = reader.readLine(); + } + String xQuery = builder.toString(); + reader.close(); + return xQuery; + } catch (IOException e) { + throw new MessagingException("Error while reading the xQuery resource", e); + } + } +} diff --git a/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/transformer/XQueryTransformer.java b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/transformer/XQueryTransformer.java new file mode 100644 index 0000000..a82c62a --- /dev/null +++ b/spring-integration-xquery/src/main/java/org/springframework/integration/xquery/transformer/XQueryTransformer.java @@ -0,0 +1,127 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.transformer; + +import java.util.List; + +import org.springframework.integration.Message; +import org.springframework.integration.transformer.AbstractTransformer; +import org.springframework.integration.xquery.core.XQueryExecutor; +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.springframework.util.Assert; +import org.w3c.dom.Node; + + +/** + * Transform the incoming message payload to the type specified in the {@link #resultType} + * attribute. Currently {@link #resultType} supports only the following values out of the box + * + * 1. {@link String} + * 2. {@link Boolean} + * 3. {@link Number} + * 4. {@link Node} + * + * For any other custom conversion, provide an instance of {@link XQueryResultMapper} in the + * {@link #resultMapper} attribute. The {@link #resultMapper} and {@link #resultType} attribute + * values are mutually exclusive to each other. If none of the above two attributes are + * provided then the value of the {@link #resultType} defaults to {@link String}. + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +@SuppressWarnings("rawtypes") +public class XQueryTransformer extends AbstractTransformer { + + private XQueryExecutor executor; + + private Class resultType; + + private XQueryResultMapper resultMapper; + + @Override + public void onInit() { + Assert.notNull(executor,"No XQueryExecutor instance provided"); + if(resultMapper == null && resultType == null) { + resultType = String.class; + } + } + + /* (non-Javadoc) + * @see org.springframework.integration.transformer.AbstractTransformer#doTransform(org.springframework.integration.Message) + */ + @SuppressWarnings("unchecked") + @Override + protected Object doTransform(Message message) throws Exception { + Object transformed; + List queryResult; + if(resultType != null) { + queryResult = (List) executor.execute(message, resultType); + } + else { + queryResult = executor.execute(message, resultMapper); + } + + if(queryResult != null && queryResult.size() == 1) { + transformed = queryResult.get(0); + } + else { + transformed = queryResult; + } + + return transformed; + } + + /** + * Sets the XQuery executor instance to be used by the {@link XQueryTransformer} + * @param executor + */ + public void setExecutor(XQueryExecutor executor) { + Assert.notNull(executor,"Provide a non null XQueryExecutor instance"); + this.executor = executor; + } + + /** + * Sets the Type of the result, if none specified and if a {@link XQueryResultMapper} instance is + * not provided, String is assumed by default. + * The permitted value of the class is one of the + * String.class, Boolean.class, Number.class or Node.class. For any other type of class + * Provide an instance of {@link XQueryResultMapper} + * + * @param resultType + */ + public void setResultType(Class resultType) { + Assert.notNull(resultType,"Provide a non null value for the result type"); + Assert.isTrue(resultMapper == null,"Only one of the result mapper of the resultType can be set"); + Assert.isTrue(String.class == resultType || Boolean.class == resultType + || Number.class == resultType || Node.class == resultType, + "Valid values for the result type class is String, Boolean, Number or Node, " + + "for any other type, provide a custom implementation of XQueryResultMapper"); + this.resultType = resultType; + } + + /** + * Sets the ResultMapper to be used for mapping the result of the XQuery Object to + * an appropriate object. + * @param resultMapper + */ + public void setResultMapper(XQueryResultMapper resultMapper) { + Assert.notNull(resultMapper,"Provide a non null value for the result mapper"); + Assert.isTrue(resultType == null,"Only one of the result mapper of the resultType can be set"); + this.resultMapper = resultMapper; + } +} diff --git a/spring-integration-xquery/src/main/resources/META-INF/spring.handlers b/spring-integration-xquery/src/main/resources/META-INF/spring.handlers new file mode 100644 index 0000000..395971d --- /dev/null +++ b/spring-integration-xquery/src/main/resources/META-INF/spring.handlers @@ -0,0 +1 @@ +http\://www.springframework.org/schema/integration/xquery=org.springframework.integration.xquery.config.xml.IntegrationXQueryNamespaceHandler \ No newline at end of file diff --git a/spring-integration-xquery/src/main/resources/META-INF/spring.schemas b/spring-integration-xquery/src/main/resources/META-INF/spring.schemas new file mode 100644 index 0000000..5826a10 --- /dev/null +++ b/spring-integration-xquery/src/main/resources/META-INF/spring.schemas @@ -0,0 +1,2 @@ +http\://www.springframework.org/schema/integration/xquery/spring-integration-xquery-2.2.xsd=org/springframework/integration/xquery/config/spring-integration-xquery-2.2.xsd +http\://www.springframework.org/schema/integration/xquery/spring-integration-xquery.xsd=org/springframework/integration/xquery/config/spring-integration-xquery-2.2.xsd \ No newline at end of file diff --git a/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery-2.2.xsd b/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery-2.2.xsd new file mode 100644 index 0000000..f90a7b9 --- /dev/null +++ b/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery-2.2.xsd @@ -0,0 +1,318 @@ + + + + + + + + + + Defines the configuration elements for Spring + Integration's Xquery support. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The common attributes that would be used for all + the xquery components + + + + + + The reference to the XQDataSource that will be + provided by the user to + execute the provided XQuery. If none is + provided, then the default + implementation will be used. + + + + + + + The classpath or the file system resource path to + the file containing + the + xquery, typically .xq file. This attribute is + mutually exclusive with the + xquery attribute and the xquery + subelement + + + + + + + The String representing the XQuery that needs to + be executed. Either + this attribute or the xquery sub element needs + to be provided. + + + + + + + Specify the Converter to use when converting + payloads prior to evaluation. + The DefaultXmlPayloadConverter is used + if this reference is not + provided, and it + should be sufficient in + most cases since it can convert from Node, + Document, Source, + File, + and String typed payloads. If you need to extend beyond the + capabilities of + that default implementation, then an upstream + Transformer is probably a + better option + than providing a reference to + a custom implementation of this strategy + here. + + + + + + + + + + + + + + + + The subelement of the xquery based component that + will be used to + specify the + parameters for the xquery + + + + + + The mandatory attribute that will be used to + specify the name of the + XQuery parameter + + + + + + + The attribute that will be used to specify the + static value to be used + for the named + parameter. + + + + + + + This attribute, mutually exclusive with value and + expression that is + used to specify + reference to some other bean in + the application context. + + + + + + + The attribute mutually exclusive with ref and + value attribute, this + will be + used to provide the expression that + would be evaluated on the incoming + message + to derive the value of the + header. + + + + + + + + + The element that will be the sub element of all + the XQuery components. + It will be used to provide the XQuery string + to these XQuery + components. + + + + + + + + One or more xquery-parameter elements will be used + to specify the + names and one of the three attributes used to derive + the + value of the parameter + + + + + + + + + ]]> + + + + + + + + + + + + + + + + + + + + + + + The type definition for the XQuery router + + + + + + + + + + + + + + This attribute, only valid for a transformer is + used to configure the + property that instructs the component to + format the output xml if + one is produced by the transformer after + XQuery transformation. By default + the output is not formatted. + + + + + + + The expected type of the result after + transformation of the + input payload. The value is the fully + qualified name of the class + The default value assumed in + java.lang.String. + If a class is provided using this attribute + which is other than + java.lang.String, java.lang.Number, + java.lang.Boolean or + org.w3c.dom.Node, + then you need to have a + mapper registered using the mapping child + element. + If a + transformation to any other type is needed and you + dont want to + provide + the mapping child element, then provide a + reference to the + xquery-result-mapper attribute. + This attribute is + mutually + exclusive to the xquery-result-mapper attribute. + + + + + + + + This attribute allows the user to provide + mapper instance that would be + used to map the result of the XQuery + executed to a desired target type of the transformer. + + + + + + + + + + + \ No newline at end of file diff --git a/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery.gif b/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery.gif new file mode 100644 index 0000000..1a348d8 Binary files /dev/null and b/spring-integration-xquery/src/main/resources/org/springframework/integration/xquery/config/spring-integration-xquery.gif differ diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/DummyXmlPayloadConverter.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/DummyXmlPayloadConverter.java new file mode 100644 index 0000000..9dfcbc4 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/DummyXmlPayloadConverter.java @@ -0,0 +1,54 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery; + +import javax.xml.transform.Source; + +import org.springframework.integration.xml.XmlPayloadConverter; +import org.w3c.dom.Document; +import org.w3c.dom.Node; + +/** + * The Dummy Xml payload converter class that would be used for parser tests + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class DummyXmlPayloadConverter implements XmlPayloadConverter { + + /* (non-Javadoc) + * @see org.springframework.integration.xml.XmlPayloadConverter#convertToDocument(java.lang.Object) + */ + public Document convertToDocument(Object object) { + return null; + } + + /* (non-Javadoc) + * @see org.springframework.integration.xml.XmlPayloadConverter#convertToNode(java.lang.Object) + */ + public Node convertToNode(Object object) { + return null; + } + + /* (non-Javadoc) + * @see org.springframework.integration.xml.XmlPayloadConverter#convertToSource(java.lang.Object) + */ + public Source convertToSource(Object object) { + return null; + } + +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests.java new file mode 100644 index 0000000..37bee4a --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests.java @@ -0,0 +1,114 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; +import java.util.Map; + +import javax.xml.xquery.XQDataSource; + +import junit.framework.Assert; +import net.sf.saxon.xqj.SaxonXQDataSource; + +import org.junit.Test; +import org.springframework.context.support.ClassPathXmlApplicationContext; +import org.springframework.core.io.ClassPathResource; +import org.springframework.core.io.Resource; +import org.springframework.integration.endpoint.EventDrivenConsumer; +import org.springframework.integration.test.util.TestUtils; +import org.springframework.integration.xml.XmlPayloadConverter; +import org.springframework.integration.xquery.DummyXmlPayloadConverter; +import org.springframework.integration.xquery.router.XQueryRouter; +import org.springframework.integration.xquery.support.XQueryParameter; + + +/** + * The test case for the XQuery router parser + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class XQueryRouterParserTests { + + private ClassPathXmlApplicationContext ctx; + private EventDrivenConsumer consumer; + + + @Test + public void routerOne() { + setUp("xqueryRouterOne"); + XQueryRouter router = TestUtils.getPropertyValue(consumer, "handler", XQueryRouter.class); + Assert.assertNotNull(TestUtils.getPropertyValue(router, "executor.xQuery", String.class)); + Assert.assertEquals(SaxonXQDataSource.class, + TestUtils.getPropertyValue(router, "executor.xqDataSource", XQDataSource.class).getClass()); + @SuppressWarnings("unchecked") + Map params = + TestUtils.getPropertyValue(router, "executor.xQueryParameterMap",Map.class); + Assert.assertEquals(2, params.size()); + Assert.assertTrue(params.containsKey("name")); + Assert.assertTrue(params.containsKey("class")); + XQueryParameter param = params.get("name"); + Assert.assertEquals("name", param.getParameterName()); + Assert.assertEquals("headers['name']", + TestUtils.getPropertyValue(param, "messageProcessor.expression.expression",String.class)); + + destroy(); + } + + @Test + public void routerTwo() { + setUp("xqueryRouterTwo"); + XQueryRouter router = TestUtils.getPropertyValue(consumer, "handler", XQueryRouter.class); + Assert.assertNotNull(TestUtils.getPropertyValue(router, "executor.xQuery", String.class)); + Assert.assertEquals(DummyXQDataSource.class, + TestUtils.getPropertyValue(router, "executor.xqDataSource", XQDataSource.class).getClass()); + Assert.assertEquals(DummyXmlPayloadConverter.class, + TestUtils.getPropertyValue(router,"executor.converter",XmlPayloadConverter.class).getClass()); + @SuppressWarnings("unchecked") + Map params = + TestUtils.getPropertyValue(router, "executor.xQueryParameterMap",Map.class); + Assert.assertEquals(1, params.size()); + Assert.assertTrue(params.containsKey("name")); + XQueryParameter param = params.get("name"); + Assert.assertEquals("name", param.getParameterName()); + Assert.assertEquals("name", + TestUtils.getPropertyValue(param, "parameterValue",String.class)); + destroy(); + } + + @Test + public void routerThree() { + setUp("xqueryRouterThree"); + XQueryRouter router = TestUtils.getPropertyValue(consumer, "handler", XQueryRouter.class); + Assert.assertNotNull(TestUtils.getPropertyValue(router, "executor.xQuery", String.class)); + Assert.assertEquals(ClassPathResource.class, TestUtils.getPropertyValue(router, "executor.xQueryFileResource",Resource.class).getClass()); + destroy(); + } + + private void setUp(String beanName) { + ctx = new ClassPathXmlApplicationContext("XQueryRouterParserTests-context.xml",XQueryRouterParserTests.class); + consumer = ctx.getBean(beanName, EventDrivenConsumer.class); + } + + + public void destroy() { + ctx.close(); + } + + public static class DummyXQDataSource extends SaxonXQDataSource { + + } +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests.java new file mode 100644 index 0000000..0a688a2 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests.java @@ -0,0 +1,144 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.config.xml; + +import java.util.List; +import java.util.Map; + +import javax.xml.xquery.XQDataSource; +import javax.xml.xquery.XQResultSequence; + +import junit.framework.Assert; +import net.sf.saxon.xqj.SaxonXQDataSource; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.context.support.ClassPathXmlApplicationContext; +import org.springframework.core.io.ClassPathResource; +import org.springframework.core.io.Resource; +import org.springframework.integration.endpoint.EventDrivenConsumer; +import org.springframework.integration.test.util.TestUtils; +import org.springframework.integration.transformer.Transformer; +import org.springframework.integration.xml.XmlPayloadConverter; +import org.springframework.integration.xquery.DummyXmlPayloadConverter; +import org.springframework.integration.xquery.support.XQueryParameter; +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.springframework.integration.xquery.transformer.XQueryTransformer; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +/** + * The test class for XQuery Transformer parser + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +@ContextConfiguration +@RunWith(SpringJUnit4ClassRunner.class) +public class XQueryTransformerParserTests { + + private ClassPathXmlApplicationContext ctx; + private EventDrivenConsumer consumer; + + @Test + public void transformerOne() { + setUp("xqueryTransformerOne"); + Transformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", Transformer.class); + Assert.assertEquals(XQueryTransformer.class, transformer.getClass()); + Assert.assertEquals(String.class, TestUtils.getPropertyValue(transformer, "resultType", Class.class)); + Assert.assertNotNull(TestUtils.getPropertyValue(transformer, "executor.xQuery", String.class)); + Assert.assertEquals(SaxonXQDataSource.class, + TestUtils.getPropertyValue(transformer, "executor.xqDataSource", XQDataSource.class).getClass()); + @SuppressWarnings("unchecked") + Map params = + TestUtils.getPropertyValue(transformer, "executor.xQueryParameterMap",Map.class); + Assert.assertEquals(2, params.size()); + Assert.assertTrue(params.containsKey("name")); + Assert.assertTrue(params.containsKey("class")); + XQueryParameter param = params.get("name"); + Assert.assertEquals("name", param.getParameterName()); + Assert.assertEquals("headers['name']", + TestUtils.getPropertyValue(param, "messageProcessor.expression.expression",String.class)); + + destroy(); + } + + @Test + public void transformerTwo() { + setUp("xqueryTransformerTwo"); + XQueryTransformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", XQueryTransformer.class); + Assert.assertNotNull(TestUtils.getPropertyValue(transformer, "executor.xQuery", String.class)); + Assert.assertEquals(DummyXQDataSource.class, + TestUtils.getPropertyValue(transformer, "executor.xqDataSource", XQDataSource.class).getClass()); + Assert.assertEquals(DummyXmlPayloadConverter.class, + TestUtils.getPropertyValue(transformer,"executor.converter",XmlPayloadConverter.class).getClass()); + Assert.assertEquals(true, TestUtils.getPropertyValue(transformer, "executor.formatOutput",Boolean.class).booleanValue()); + destroy(); + } + + @Test + public void transformerThree() { + setUp("xqueryTransformerThree"); + XQueryTransformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", XQueryTransformer.class); + Assert.assertNotNull(TestUtils.getPropertyValue(transformer, "executor.xQuery", String.class)); + Assert.assertEquals(ClassPathResource.class, TestUtils.getPropertyValue(transformer, "executor.xQueryFileResource",Resource.class).getClass()); + destroy(); + } + + @Test + public void booleanTypeResult() { + setUp("booleanResultTypeTransformer"); + XQueryTransformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", XQueryTransformer.class); + Assert.assertEquals(Boolean.class, TestUtils.getPropertyValue(transformer, "resultType", Class.class)); + } + + @Test + public void stringTypeResult() { + setUp("stringResultTypeTransformer"); + XQueryTransformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", XQueryTransformer.class); + Assert.assertEquals(String.class, TestUtils.getPropertyValue(transformer, "resultType", Class.class)); + } + + @Test + public void resultMapperProvided() { + setUp("customXQueryResultMapper"); + XQueryTransformer transformer = TestUtils.getPropertyValue(consumer, "handler.transformer", XQueryTransformer.class); + Assert.assertEquals(DummyXQueryResultMapper.class, TestUtils.getPropertyValue(transformer, "resultMapper", XQueryResultMapper.class).getClass()); + } + + + private void setUp(String beanName) { + ctx = new ClassPathXmlApplicationContext("XQueryTransformerParserTests-context.xml",XQueryTransformerParserTests.class); + consumer = ctx.getBean(beanName, EventDrivenConsumer.class); + } + + public void destroy() { + ctx.close(); + } + + public static class DummyXQDataSource extends SaxonXQDataSource { + + } + + public static class DummyXQueryResultMapper implements XQueryResultMapper { + + public List mapResults(XQResultSequence result) { + return null; + } + } +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/AbstractXQueryExecutorTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/AbstractXQueryExecutorTests.java new file mode 100644 index 0000000..06ce55d --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/AbstractXQueryExecutorTests.java @@ -0,0 +1,654 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.core; + +import java.io.File; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.xquery.XQDataSource; +import javax.xml.xquery.XQResultSequence; + +import org.junit.Assert; +import org.junit.Test; +import org.springframework.core.io.ClassPathResource; +import org.springframework.core.io.Resource; +import org.springframework.integration.Message; +import org.springframework.integration.MessagingException; +import org.springframework.integration.support.MessageBuilder; +import org.springframework.integration.test.util.TestUtils; +import org.springframework.integration.xquery.support.AbstractXQueryResultMapper; +import org.springframework.integration.xquery.support.BooleanResultMapper; +import org.springframework.integration.xquery.support.NodeResultMapper; +import org.springframework.integration.xquery.support.NumberResultMapper; +import org.springframework.integration.xquery.support.StringResultMapper; +import org.springframework.integration.xquery.support.XQueryParameter; +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.w3c.dom.Node; + +/** + * The base test class for the XQueryExecutor tests + * + * @author Amol Nayak + * @since 2.2 + * + */ +public abstract class AbstractXQueryExecutorTests { + + + private final static String EXT_VARIABLE_XQUERY = + "declare variable $name as xs:string external;" + + "declare variable $class as xs:int external;" + + " for $student in /mappings/students/student," + + " $subject in /mappings/subjects/subject " + + "where $student/@id = $subject/students/studentId " + + "and $student/name = $name " + + "and $student/class = $class " + + "return $subject/name/text()"; + + private final String xmlString = "" + + "Mike" + + "29" + + ""; + + + /** + * Test if default created result mappers are appropriately instantiated + */ + @Test + public void initializeDefaultMappers() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + @SuppressWarnings("rawtypes") + Map executorMap = TestUtils.getPropertyValue(executor, "resultMappers", Map.class); + Assert.assertNotNull(executorMap); + Assert.assertEquals(4, executorMap.size()); + Assert.assertEquals(StringResultMapper.class, executorMap.get(String.class).getClass()); + Assert.assertEquals(BooleanResultMapper.class, executorMap.get(Boolean.class).getClass()); + Assert.assertEquals(NumberResultMapper.class, executorMap.get(Number.class).getClass()); + Assert.assertEquals(NodeResultMapper.class, executorMap.get(Node.class).getClass()); + } + + /** + * Tests of the registered mappers take priority over the defaults + */ + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test + public void registerCustomMappers() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello'"); + Map map = new HashMap(); + map.put(MyCustomClass.class, new XQueryResultMapper() { + public List mapResults(XQResultSequence result) { + // TODO Auto-generated method stub + return null; + } + }); + map.put(Node.class, new CustomNodeMapper()); + executor.setResultMappers(map); + executor.afterPropertiesSet(); + Map executorMap = TestUtils.getPropertyValue(executor, "resultMappers", Map.class); + Assert.assertNotNull(executorMap); + Assert.assertEquals(5, executorMap.size()); + Assert.assertEquals(StringResultMapper.class, executorMap.get(String.class).getClass()); + Assert.assertEquals(BooleanResultMapper.class, executorMap.get(Boolean.class).getClass()); + Assert.assertEquals(NumberResultMapper.class, executorMap.get(Number.class).getClass()); + Assert.assertEquals(CustomNodeMapper.class, executorMap.get(Node.class).getClass()); + } + + + /** + * Tries to execute the result passing an unmapped class + */ + @Test + public void executeForUnknownClassType() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + try { + executor.execute(MessageBuilder.withPayload("").build(), MyCustomClass.class); + } catch (IllegalArgumentException e) { + Assert.assertEquals("No Result mapper found for the type org.springframework.integration.xquery.core.AbstractXQueryExecutorTests$MyCustomClass", + e.getMessage()); + } + } + + /** + * @return + */ + protected abstract XQueryExecutor getExecutor(); + + /** + * Test with null message + */ + @Test + public void withNullMessage() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + try { + executor.execute(null, String.class); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Non null message expected", e.getMessage()); + } + + } + + @Test + public void executeWithStringForNonLeaf() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery(".//person"); + executor.afterPropertiesSet(); + List names = executor.executeForString(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + } + + + @Test + public void executeWithBooleanForNonLeaf() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//person"); + executor.afterPropertiesSet(); + List names = executor.executeForBoolean(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + Assert.assertTrue(names.contains(Boolean.FALSE)); + } + + + @Test + public void executeWithNumberForNonLeaf() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//person"); + executor.afterPropertiesSet(); + @SuppressWarnings("unused") + List names; + try { + names = executor.executeForNumber(MessageBuilder.withPayload(xmlString).build()); + } catch (MessagingException e) { + Assert.assertEquals(NumberFormatException.class,e.getCause().getClass()); + } + } + + + /** + * Test case to execute the XQuery and return a {@link List} of {@link String} + */ + @Test + public void executeWithString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery(".//person/name/text()"); + executor.afterPropertiesSet(); + List names = executor.executeForString(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + Assert.assertTrue(names.contains("Mike")); + } + + + /** + * Test case to execute the XQuery and return a {@link List} of {@link Boolean} + */ + @Test + public void executeWithBoolean() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//person/@active"); + executor.afterPropertiesSet(); + List names = executor.executeForBoolean(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + Assert.assertTrue(names.contains(Boolean.TRUE)); + } + + + /** + * Test case to execute the XQuery and return a {@link List} of {@link Number} + */ + @Test + public void executeWithNumber() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//person/age/text()"); + executor.afterPropertiesSet(); + List names = executor.executeForNumber(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + Assert.assertTrue(names.contains(Long.valueOf(29))); + } + + + /** + * Test case to execute the XQuery and return a {@link List} of {@link Node} + */ + @Test + public void executeWithNode() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//person"); + executor.afterPropertiesSet(); + List names = executor.executeForNode(MessageBuilder.withPayload(xmlString).build()); + Assert.assertNotNull(names); + Assert.assertEquals(1, names.size()); + Assert.assertEquals("person",names.get(0).getLocalName()); + } + + + /** + * Test with null message + */ + @Test + public void withNullType() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + try { + executor.execute(MessageBuilder.withPayload("").build(),(Class) null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Non null type expected", e.getMessage()); + } + + } + + + /** + * Executes the case where the router has no parameters but the query expects parameters + */ + @Test + public void noParametersProvided() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery(EXT_VARIABLE_XQUERY); + try { + executor.afterPropertiesSet(); + } catch (MessagingException e) { + Assert.assertEquals("Expecting 2 parameters in the xquery, but none provided to the router", e.getMessage()); + } + } + + /** + * Execute the case where parameters are provided, but some or all of the parameters are missing + */ + @Test + public void fewParametersProvided() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery(EXT_VARIABLE_XQUERY); + executor.addXQueryParameter(new XQueryParameter("class",Integer.valueOf(3))); + try { + executor.afterPropertiesSet(); + } catch (MessagingException e) { + Assert.assertEquals("Missing parameter(s) [$name]", e.getMessage()); + } + } + + /** + * Sets null XQuery, should get an exception + */ + @Test + public void setNullXQuery() { + XQueryExecutor executor = getExecutor(); + try { + executor.setXQuery(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null XQuery", e.getMessage()); + } + } + + + /** + * Sets the XQuery file resource and then the xquery + */ + @Test + public void setResourceAndXQuery() { + XQueryExecutor executor = getExecutor(); + Resource res = new ClassPathResource("/org/springframework/integration/xquery/XQuery.xq"); + Assert.assertTrue(res.exists()); + executor.setXQueryFileResource(res); + try { + executor.setXQuery("'Hello World'"); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Only one of XQuery resource file or XQuery may be specified", e.getMessage()); + } + Assert.assertNull(TestUtils.getPropertyValue(executor, "xQuery")); + executor.addXQueryParameter(new XQueryParameter("name", "headers['studentName']")); + executor.addXQueryParameter(new XQueryParameter("class", Integer.valueOf(1))); + executor.afterPropertiesSet(); + Assert.assertNotNull(TestUtils.getPropertyValue(executor, "xQuery",String.class)); + } + + /** + * Initialize the router without setting the xquery + */ + @Test + public void withoutXQuery() { + XQueryExecutor executor = getExecutor(); + try { + executor.afterPropertiesSet(); + } catch (IllegalArgumentException e) { + Assert.assertEquals("One of XQuery or the XQuery resource is mandatory", e.getMessage()); + } + } + + /** + *Sets the XQuery and then the resource + */ + @Test + public void setXQueryAndResource() { + XQueryExecutor executor = getExecutor(); + Resource res = new ClassPathResource("org/springframework/integration/xquery/XQuery.xq"); + Assert.assertTrue(res.exists()); + executor.setXQuery("'Hello World'"); + try { + executor.setXQueryFileResource(res); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Only one of XQuery resource file or XQuery may be specified", e.getMessage()); + } + } + + /** + *Sets a null {@link XQDataSource} instance + */ + @Test + public void setNullXQataSource() { + XQueryExecutor executor = getExecutor(); + try { + executor.setXQDataSource(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null instance of the XQDatasource", e.getMessage()); + } + } + + + /** + * Tests the router with valid xml payload. The values returned will be the + * text content of the node, if the node is a text or attribute type + */ + @Test + public void withValidPayload() { + withValidPayloadInternal(true); + } + + /** + * Tests the router with valid xml payload. The values returned will be the + * {@link Node}, irrespective of the type of the node + */ + @Test + public void withValidPayload2() { + withValidPayloadInternal(false); + } + + /** + * + */ + private void withValidPayloadInternal(boolean extractNodeText) { + File file = new File("./src/test/resources/org/springframework/integration/xquery/SubjectMapping.xml"); + Message message = MessageBuilder.withPayload(file) + .setHeader("studentName", "Jughead") + .build(); + XQueryExecutor executor = getExecutor(); + executor.setXQuery(EXT_VARIABLE_XQUERY); + executor.addXQueryParameter(new XQueryParameter("name", "headers['studentName']")); + executor.addXQueryParameter(new XQueryParameter("class", Integer.valueOf(1))); + executor.afterPropertiesSet(); + List subjects; + if(extractNodeText) { + subjects = new ArrayList(executor.executeForString(message)); + } + else { + subjects = new ArrayList(executor.executeForNode(message)); + } + Assert.assertNotNull(subjects); + Assert.assertEquals(2, subjects.size()); + if(extractNodeText) { + Assert.assertEquals(String.class, subjects.get(0).getClass()); + Assert.assertTrue(subjects.contains("Cooking")); + Assert.assertTrue(subjects.contains("Math")); + } + else { + Assert.assertTrue(Node.class.isAssignableFrom(subjects.get(0).getClass())); + } + } + + /** + * Tests with a query that will generate a numeric value and we get the result as {@link Number} + */ + @Test + public void withNumericExpression() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("2 + 2"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.get(0).intValue() == 4); + + } + + /** + *Tests a query that will generate a decimal value and we get the result as a {@link Number} + */ + @Test + public void withDecimalExpression() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("2.0 + 2.1"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Double.valueOf(4.1))); + + } + + /** + * Execute the XQuery that gives a boolean value and get the value as a Boolean + */ + @Test + public void withBooleanResult() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("1 = 1"); + executor.afterPropertiesSet(); + List result = executor.executeForBoolean(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Boolean.TRUE)); + } + + /** + *The XQuery gives a string value and we want the result to be a string value + */ + @Test + public void getTextString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + List result = executor.executeForString(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains("Hello World")); + } + + /** + *The XQuery gives a boolean value and we want the result to be a string value + */ + @Test + public void getBooleanAsTextString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("1 = 2"); + executor.afterPropertiesSet(); + List result = executor.executeForString(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains("false")); + } + + /** + *The XQuery gives a text value in the node and we want the result to be a string value + */ + @Test + public void getTextNodeAsString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//test/text()"); + executor.afterPropertiesSet(); + List result = executor.executeForString(MessageBuilder.withPayload("Some Value").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains("Some Value")); + } + + /** + *The XQuery gives a text value in the node and we want the result to be a Boolean + */ + @Test + public void getTextNodeAsBoolean() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//test/text()"); + executor.afterPropertiesSet(); + List result = executor.executeForBoolean(MessageBuilder.withPayload("Some Value").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Boolean.FALSE)); + } + + /** + *The XQuery gives a text value in the node and we want the result to be a Long + */ + @Test + public void getTextNodeAsLong() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//number/text()"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("1").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Long.valueOf(1))); + } + + /** + *The XQuery gives a text value in the node and we want the result to be a Long + */ + @Test + public void getTextNodeAsDouble() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("//number/text()"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("1.1").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Double.valueOf(1.1))); + } + + + + /** + * Tests by using a String that is a non decimal number and we get the value as a {@link Number} + */ + @Test + public void withNonDecimalStringExpression() { + XQueryExecutor executor = getExecutor(); + executor.setResultMappers(Collections.singletonMap(Number.class, + (XQueryResultMapper)new NumberResultMapper())); + executor.setXQuery("'4'"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Long.valueOf(4))); + } + + /** + * Tests by using a String that is a decimal number and we get the value as a {@link Number} + */ + @Test + public void withDecimalStringExpression() { + XQueryExecutor executor = getExecutor(); + executor.setResultMappers(Collections.singletonMap(Number.class, + (XQueryResultMapper)new NumberResultMapper())); + executor.setXQuery("'4.1'"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Double.valueOf(4.1))); + } + + /** + * Tests by getting the Integer value and getting the result as {@link String} + */ + @Test + public void getIntegerAsString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("4"); + executor.afterPropertiesSet(); + List result = executor.executeForString(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains("4")); + } + + + + /** + * Uses a decimal value and gets the result as {@link String} + */ + @Test + public void getDecimalAsString() { + XQueryExecutor executor = getExecutor(); + executor.setXQuery("4.1"); + executor.afterPropertiesSet(); + List result = executor.executeForString(MessageBuilder.withPayload("").build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains("4.1")); + } + +// @Test +// public void getCurrentDate() { +// XQueryExecutor executor = new XQueryExecutor(); +// executor.setXQuery("current-date()"); +// executor.afterPropertiesSet(); +// executor.executeForString(MessageBuilder.withPayload("").build()); +// } + + + @Test + public void withStringExpression2() { + XQueryExecutor executor = getExecutor(); + executor.setResultMappers(Collections.singletonMap(Number.class, + (XQueryResultMapper)new NumberResultMapper())); + executor.setXQuery("/person/age/text()"); + executor.afterPropertiesSet(); + List result = executor.executeForNumber(MessageBuilder.withPayload(xmlString).build()); + Assert.assertEquals(1, result.size()); + Assert.assertTrue(result.contains(Long.valueOf(29))); + } + + @Test + public void withFormatingFlag() { + XQueryExecutor executor = getExecutor(); + executor.setFormatOutput(true); + executor.setXQuery("'Hello World'"); + executor.afterPropertiesSet(); + //should not fail + executor.executeForString(MessageBuilder.withPayload("").build()); + @SuppressWarnings("unchecked") + Map, XQueryResultMapper> mappers = TestUtils.getPropertyValue(executor, "resultMappers", Map.class); + for(Object val:mappers.values()) { + if(val instanceof AbstractXQueryResultMapper) { + Assert.assertEquals(true, + TestUtils.getPropertyValue(val, "formatOutput", Boolean.class).booleanValue()); + } + } + + } + + + + private class MyCustomClass {} + private class CustomNodeMapper implements XQueryResultMapper { + public List mapResults(XQResultSequence result) { + return null; + } + + } +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SaxonXQueryExecutorTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SaxonXQueryExecutorTests.java new file mode 100644 index 0000000..387d54e --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SaxonXQueryExecutorTests.java @@ -0,0 +1,39 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.core; + + +/** + * The test class that uses the saxon's implementation in {@link XQueryExecutor} + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class SaxonXQueryExecutorTests extends AbstractXQueryExecutorTests { + + + @Override + protected XQueryExecutor getExecutor() { + //use the default one that uses Saxon's implementation + XQueryExecutor executor = new XQueryExecutor(); + return executor; + } + + +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SednaXQueryExecutorTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SednaXQueryExecutorTests.java new file mode 100644 index 0000000..57e8589 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/core/SednaXQueryExecutorTests.java @@ -0,0 +1,69 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.core; + +import javax.xml.xquery.XQDataSource; +import javax.xml.xquery.XQException; + +import net.xqj.sedna.SednaXQDataSource; + +/** + * The Test class that uses {@link SednaXQDataSource} in {@link XQueryExecutor} + * + * This test is intentionally excluded from being executed by surefire as it will + * fail if the Sedna database is not up and running + * + * To run this test we need to have the Sedna XML Database up and running. + * Visit {@link http://xqj.net/sedna/} for more details about Sedna. + * + * Once the Sedna xml database is downloaded and extracted the you will find + * various executables in the bin directory, do the following to start it and create + * a new database called 'test' + * + * 1. Start the governer by executing se_gov + * 2. Create a new database called 'test' by executing se_cdb test + * 3. Start the newly created database by running se_sm test. If the database was already + * created, you can skip the step 2 and execute this step directly. + * + * Once the database is up and running, you can execute the below test case. + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class SednaXQueryExecutorTests extends AbstractXQueryExecutorTests { + + + @Override + /** + * Gets an instance of SednaXQDataSource for the tests. + * + */ + protected XQueryExecutor getExecutor() { + XQueryExecutor executor = new XQueryExecutor(); + XQDataSource ds; + try { + ds = new SednaXQDataSource(); + ds.setProperty("serverName", "localhost"); + ds.setProperty("databaseName", "test"); + } catch (XQException e) { + throw new RuntimeException(e.getMessage(), e); + } + executor.setXQDataSource(ds); + return executor; + } +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/router/XQueryRouterTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/router/XQueryRouterTests.java new file mode 100644 index 0000000..cf18ef0 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/router/XQueryRouterTests.java @@ -0,0 +1,136 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.router; + +import java.util.List; + +import junit.framework.Assert; + +import org.junit.Test; +import org.springframework.integration.support.MessageBuilder; +import org.springframework.integration.test.util.TestUtils; +import org.springframework.integration.xquery.core.XQueryExecutor; + + +/** + * The Test class for the XQuery router + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryRouterTests { + + private static final String STUDENT_XML = "" + + "" + + "Name1" + + "21" + + "" + + "" + + "Name2" + + "22" + + "" + + ""; + + /** + * Tests the executor without seting the XQueryExecutor's instance + */ + @Test + public void withoutExecutor() { + XQueryRouter router = new XQueryRouter(); + try { + router.afterPropertiesSet(); + } catch (IllegalArgumentException e) { + Assert.assertEquals("No XQueryExecutor instance provided", e.getMessage()); + } + } + + + /** + * Tries setting the executor instance of the {@link XQueryRouter} to null. + */ + @Test + public void setNullExecutor() { + XQueryRouter router = new XQueryRouter(); + try { + router.setExecutor(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null implementation of the executor", e.getMessage()); + } + } + + /** + * Gets the channel keys for the given XQuery expression + */ + @Test + public void getChannelKeys() { + XQueryRouter router = new XQueryRouter(); + router.setExecutor(getExecutor("//test/text()")); + router.afterPropertiesSet(); + List keys= + router.getChannelKeys(MessageBuilder.withPayload("Test").build()); + Assert.assertNotNull(keys); + Assert.assertEquals(1, keys.size()); + Assert.assertTrue(keys.contains("Test")); + } + + @Test + public void testDefaultResultType() { + XQueryRouter router = new XQueryRouter(); + router.setExecutor(getExecutor("'Hello'")); + router.afterPropertiesSet(); + Assert.assertEquals(String.class, + TestUtils.getPropertyValue(router, "resultType", Class.class)); + + } + + @Test + public void getChannelKeysAsStrings() { + XQueryRouter router = new XQueryRouter(); + router.setExecutor(getExecutor("/students/student/name/text()")); + router.afterPropertiesSet(); + List keys = router.getChannelKeys(MessageBuilder.withPayload(STUDENT_XML).build()); + Assert.assertEquals(2, keys.size()); + Assert.assertTrue(keys.contains("Name1")); + Assert.assertTrue(keys.contains("Name2")); + } + + /** + * The method demonstrates the conversion of a Numeric type to a String with get + * channel keys method. + */ + @Test + public void getChannelKeysAsStrings2() { + XQueryRouter router = new XQueryRouter(); + router.setExecutor(getExecutor("/students/student/age/text()")); + router.afterPropertiesSet(); + List keys = router.getChannelKeys(MessageBuilder.withPayload(STUDENT_XML).build()); + Assert.assertEquals(2, keys.size()); + Assert.assertTrue(keys.contains("21")); + Assert.assertTrue(keys.contains("22")); + } + + /** + * @return + */ + private XQueryExecutor getExecutor(String xQuery) { + XQueryExecutor executor = new XQueryExecutor(); + executor.setXQuery(xQuery); + executor.afterPropertiesSet(); + return executor; + } + +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/support/XQueryParameterTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/support/XQueryParameterTests.java new file mode 100644 index 0000000..5c980d3 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/support/XQueryParameterTests.java @@ -0,0 +1,171 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.support; + +import java.util.Arrays; +import java.util.Collection; +import java.util.List; + +import junit.framework.Assert; + +import org.junit.Test; +import org.springframework.integration.Message; +import org.springframework.integration.support.MessageBuilder; +import org.springframework.integration.test.util.TestUtils; + +/** + * The test class for {@link XQueryParameter} class + * + * @author Amol Nayak + * + * @since 2.2 + * + */ +public class XQueryParameterTests { + + /** + * Sets a null parameter name, should throw an exception + */ + @Test + public void setNullParameterName() { + try { + @SuppressWarnings("unused") + XQueryParameter param = new XQueryParameter(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Non null non empty String value expected for parameter name", e.getMessage()); + } + } + + /** + * Sets a null parameter name, should throw an exception + */ + @Test + public void setEmptyParameterName() { + try { + @SuppressWarnings("unused") + XQueryParameter param = new XQueryParameter(""); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Non null non empty String value expected for parameter name", e.getMessage()); + } + } + + /** + * Sets the valid parameter name + */ + @Test + public void setValidParameterName() { + XQueryParameter param = new XQueryParameter("testName"); + Assert.assertEquals("testName", param.getParameterName()); + } + + + /** + * Sets both the expression then the parameter value, should throw an exception + */ + @Test + public void setParameterExpressionThenValue() { + XQueryParameter param = new XQueryParameter("testParameter"); + param.setExpression("headers['someHeader']"); + try { + param.setParameterValue("Some Value"); + } catch (IllegalArgumentException e) { + Assert.assertEquals("The parameter value and expression are mutually " + + "exclusive, parameter expression already set", e.getMessage()); + } + Assert.assertEquals(false, TestUtils.getPropertyValue(param,"isValueSet", Boolean.class).booleanValue()); + Assert.assertEquals("headers['someHeader']", + TestUtils.getPropertyValue(param, "messageProcessor.expression.expression",String.class)); + } + + /** + * Sets both the value then the parameter expression, should throw an exception + */ + @Test + public void setParameterValueThenExpression() { + XQueryParameter param = new XQueryParameter("testParameter"); + param.setParameterValue("Some Value"); + try { + param.setExpression("headers['someHeader']"); + } catch (IllegalArgumentException e) { + Assert.assertEquals("The parameter value and expression are mutually exclusive" + + ", parameter value already set", e.getMessage()); + } + Assert.assertEquals(true, TestUtils.getPropertyValue(param,"isValueSet", Boolean.class).booleanValue()); + } + + /** + * Sets the parameter name and its value from the constructor + */ + @Test + public void setParameterValueInConstructor() { + XQueryParameter param = new XQueryParameter("testName", (Object)"testValue"); + Assert.assertEquals(true, TestUtils.getPropertyValue(param, "isValueSet",Boolean.class).booleanValue()); + Assert.assertEquals("testName", param.getParameterName()); + Assert.assertEquals("testValue", TestUtils.getPropertyValue(param, "parameterValue", String.class)); + } + + /** + * Sets the parameter value from the constructor + */ + @Test + public void setParameterExpressionInConstructor() { + XQueryParameter param = new XQueryParameter("testName", "headers['someHeader']"); + Assert.assertEquals(false, TestUtils.getPropertyValue(param, "isValueSet",Boolean.class).booleanValue()); + Assert.assertEquals("testName", param.getParameterName()); + Assert.assertEquals("headers['someHeader']", TestUtils.getPropertyValue(param, "expression", String.class)); + Assert.assertEquals("headers['someHeader']", + TestUtils.getPropertyValue(param, "messageProcessor.expression.expression",String.class)); + } + + /** + * Sets the expression string twice, should throw an exception + */ + @Test + public void setExpressionTwice() { + XQueryParameter param = new XQueryParameter("paramName"); + param.setExpression("headers['headerValue']"); + try { + param.setExpression("headers['headerV']"); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Expression string is already set once, cannot reset it", e.getMessage()); + } + } + + /** + * Evaluate the parameter to get the static value set + */ + @Test + public void executeForStaticValue() { + XQueryParameter param = new XQueryParameter("paramName", Integer.valueOf(10)); + Object value = param.evaluate(null); + Assert.assertEquals(value, Integer.valueOf(10)); + } + + /** + * Execute an expression to get the return values + */ + @Test + public void executeExpressionValue() { + XQueryParameter param = new XQueryParameter("paramName","headers['numbers'].?[#this > 5]"); + List numbers = Arrays.asList(1,3,4,2,5,6,7); + Message message = MessageBuilder.withPayload("") + .setHeader("numbers", numbers) + .build(); + @SuppressWarnings("unchecked") + Collection coll = (Collection)param.evaluate(message); + Assert.assertEquals(2, coll.size()); + } +} diff --git a/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/transformer/XQueryTransformerTests.java b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/transformer/XQueryTransformerTests.java new file mode 100644 index 0000000..68865c2 --- /dev/null +++ b/spring-integration-xquery/src/test/java/org/springframework/integration/xquery/transformer/XQueryTransformerTests.java @@ -0,0 +1,239 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * 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 org.springframework.integration.xquery.transformer; + +import java.math.BigInteger; +import java.util.List; + +import javax.xml.xquery.XQResultSequence; + +import junit.framework.Assert; + +import org.junit.Test; +import org.springframework.core.io.ClassPathResource; +import org.springframework.integration.support.MessageBuilder; +import org.springframework.integration.test.util.TestUtils; +import org.springframework.integration.xquery.core.XQueryExecutor; +import org.springframework.integration.xquery.support.XQueryResultMapper; +import org.w3c.dom.Node; + +/** + * The Test class for the {@link XQueryTransformer} class + * + * @author Amol Nayak + * @since 2.2 + * + */ +public class XQueryTransformerTests { + + @Test + public void withNoExecutor() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.afterPropertiesSet(); + } catch (IllegalArgumentException e) { + Assert.assertEquals("No XQueryExecutor instance provided", e.getMessage()); + } + } + + + @Test + public void withNullExecutor() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null XQueryExecutor instance", e.getMessage()); + } + } + + @Test + public void withNoMapperAndResultType() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.afterPropertiesSet(); + Assert.assertEquals(String.class, TestUtils.getPropertyValue(transformer, "resultType",Class.class)); + } + + @Test + public void withStringResultType() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.setResultType(String.class); + transformer.afterPropertiesSet(); + Assert.assertEquals(String.class, TestUtils.getPropertyValue(transformer, "resultType",Class.class)); + } + + + @Test + public void withNumberResultType() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.setResultType(Number.class); + transformer.afterPropertiesSet(); + Assert.assertEquals(Number.class, TestUtils.getPropertyValue(transformer, "resultType",Class.class)); + } + + + + @Test + public void withBooleanResultType() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.setResultType(Boolean.class); + transformer.afterPropertiesSet(); + Assert.assertEquals(Boolean.class, TestUtils.getPropertyValue(transformer, "resultType",Class.class)); + } + + + @Test + public void withNodeResultType() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.setResultType(Node.class); + transformer.afterPropertiesSet(); + Assert.assertEquals(Node.class, TestUtils.getPropertyValue(transformer, "resultType",Class.class)); + } + + @Test + public void withUnknownResultType() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("//hello")); + transformer.setResultType(getClass()); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Valid values for the result type class is String, Boolean, Number or Node, " + + "for any other type, provide a custom implementation of XQueryResultMapper", e.getMessage()); + } + } + + @Test + public void setFirstTypeThenMapper() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setResultType(String.class); + transformer.setResultMapper(new DummyXQueryResultMapper()); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Only one of the result mapper of the resultType can be set", e.getMessage()); + } + } + + @Test + public void setFirstMapperThenType() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setResultMapper(new DummyXQueryResultMapper()); + transformer.setResultType(String.class); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Only one of the result mapper of the resultType can be set", e.getMessage()); + } + } + + @Test + public void setNullMapper() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setResultMapper(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null value for the result mapper", e.getMessage()); + } + } + + @Test + public void setNullType() { + try { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setResultType(null); + } catch (IllegalArgumentException e) { + Assert.assertEquals("Provide a non null value for the result type", e.getMessage()); + } + } + + @Test + public void executeForString() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("'Hello World!'")); + transformer.afterPropertiesSet(); + try { + Object result = transformer.doTransform(MessageBuilder.withPayload("").build()); + Assert.assertNotNull(result); + Assert.assertEquals("Hello World!", result); + } catch (Exception e) { + e.printStackTrace(); + Assert.assertTrue(false); + } + } + + @Test + public void executeForInteger() { + XQueryTransformer transformer = new XQueryTransformer(); + transformer.setExecutor(getExecutor("10 + 12")); + transformer.setResultType(Number.class); + transformer.afterPropertiesSet(); + try { + Object result = transformer.doTransform(MessageBuilder.withPayload("").build()); + Assert.assertNotNull(result); + Assert.assertEquals(BigInteger.valueOf(22), result); + } catch (Exception e) { + e.printStackTrace(); + Assert.assertTrue(false); + } + } + + @Test + public void personTransformer() { + String inputXml = "" + + "" + + "" + + ""; + + XQueryTransformer transformer = new XQueryTransformer(); + XQueryExecutor executor = new XQueryExecutor(); + executor.setXQueryFileResource( + new ClassPathResource("org/springframework/integration/xquery/XQueryTransform.xq")); + executor.setFormatOutput(true); + executor.afterPropertiesSet(); + transformer.setExecutor(executor); + transformer.afterPropertiesSet(); + try { + Object transformed = transformer.doTransform(MessageBuilder.withPayload(inputXml).build()); + Assert.assertNotNull(transformed); + System.out.println(transformed); + } catch (Exception e) { + Assert.assertTrue("Caught Exception while transformation, " + e.getMessage(),false); + } + } + + private class DummyXQueryResultMapper implements XQueryResultMapper { + + public List mapResults(XQResultSequence result) { + // TODO Auto-generated method stub + return null; + } + } + + + //TODO: Refactor, Can have a common superclass for all XQuery components + /** + * @return + */ + private XQueryExecutor getExecutor(String xQuery) { + XQueryExecutor executor = new XQueryExecutor(); + executor.setXQuery(xQuery); + executor.afterPropertiesSet(); + return executor; + } +} diff --git a/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/SubjectMapping.xml b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/SubjectMapping.xml new file mode 100644 index 0000000..87f6298 --- /dev/null +++ b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/SubjectMapping.xml @@ -0,0 +1,61 @@ + + + + Jughead + 1 + + + Archie + 1 + + + Reggie + 1 + + + Moose + 1 + + + Betty + 1 + + + Veronica + 1 + + + + + Math + + 1 + 2 + 5 + + + + Physics + + 2 + 5 + 6 + + + + Chemistry + + 3 + 4 + 6 + + + + Cooking + + 1 + 5 + + + + \ No newline at end of file diff --git a/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQuery.xq b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQuery.xq new file mode 100644 index 0000000..05f9ce2 --- /dev/null +++ b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQuery.xq @@ -0,0 +1,8 @@ +declare variable $name as xs:string external; +declare variable $class as xs:int external; +for $student in /mappings/students/student, + $subject in /mappings/subjects/subject + where $student/@id = $subject/students/studentId + and $student/name = $name + and $student/class = $class +return $subject/name/text() \ No newline at end of file diff --git a/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQueryTransform.xq b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQueryTransform.xq new file mode 100644 index 0000000..d971b1f --- /dev/null +++ b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/XQueryTransform.xq @@ -0,0 +1,11 @@ + + { + for $emp in /employees/employee + return + + {string($emp/@id)} + {string($emp/@name)} + {string($emp/@name)} + + } + \ No newline at end of file diff --git a/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests-context.xml b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests-context.xml new file mode 100644 index 0000000..9ab4e01 --- /dev/null +++ b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryRouterParserTests-context.xml @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests-context.xml b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests-context.xml new file mode 100644 index 0000000..b01e16e --- /dev/null +++ b/spring-integration-xquery/src/test/resources/org/springframework/integration/xquery/config/xml/XQueryTransformerParserTests-context.xml @@ -0,0 +1,75 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file