From 132aa8a77685ec92bc90c03f987650d275a7b639 Mon Sep 17 00:00:00 2001 From: lresende Date: Mon, 30 Sep 2013 06:59:11 +0000 Subject: 2.0.1 RC1 release tag git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1527464 13f79535-47bb-0310-9956-ffa450edef68 --- .../src/test/java/datatypes/BaseFramework.java | 266 ++++++++++++ .../src/test/java/datatypes/DataTypesTestCase.java | 186 +++++++++ .../test/java/datatypes/DynamicSDOTestCase.java | 81 ++++ .../java/helloworld/SchemaCorrectionTestCase.java | 462 +++++++++++++++++++++ .../src/test/java/helloworld/WSDLGenTestCase.java | 184 ++++++++ 5 files changed, 1179 insertions(+) create mode 100644 sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/BaseFramework.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DataTypesTestCase.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DynamicSDOTestCase.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/SchemaCorrectionTestCase.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/WSDLGenTestCase.java (limited to 'sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test') diff --git a/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/BaseFramework.java b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/BaseFramework.java new file mode 100644 index 0000000000..4cae4595a4 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/BaseFramework.java @@ -0,0 +1,266 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 datatypes; + +import java.util.HashMap; +import java.util.Map; + +import javax.wsdl.Binding; +import javax.wsdl.Definition; +import javax.wsdl.Fault; +import javax.wsdl.Input; +import javax.wsdl.Message; +import javax.wsdl.Operation; +import javax.wsdl.Output; +import javax.wsdl.Part; +import javax.wsdl.Port; +import javax.wsdl.PortType; +import javax.wsdl.Service; +import javax.wsdl.Types; +import javax.wsdl.extensions.ExtensibilityElement; +import javax.wsdl.extensions.schema.Schema; +import javax.wsdl.factory.WSDLFactory; +import javax.wsdl.xml.WSDLReader; +import javax.xml.namespace.QName; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; + +import org.apache.tuscany.sca.TuscanyRuntime; +import org.apache.tuscany.sca.binding.ws.wsdlgen.WSDLServiceGenerator; +import static org.junit.Assert.assertNotNull; + +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; + + +/** + * Test ?wsdl works and that the returned WSDL is correct + * + * @version $Rev: 814373 $ $Date: 2009-09-13 19:06:29 +0100 (Sun, 13 Sep 2009) $ + */ +public class BaseFramework { + private static final String SCHEMA_NS = "http://www.w3.org/2001/XMLSchema"; + private static final String SCHEMA_NAME = "schema"; + private static final QName SCHEMA_QNAME = new QName(SCHEMA_NS, SCHEMA_NAME); + + private static Map schemaMap; + private static PortType portType; + private static boolean printWSDL = true; + private static org.apache.tuscany.sca.Node node; + + private Map prefixMap; + + public BaseFramework() { + // create a new instance of this for each of the tests + prefixMap = new HashMap(); + } + + protected Element parameterElement(String methodName) { + Operation op = portType.getOperation(methodName, null, null); + Input in = op.getInput(); + Message msg = in.getMessage(); + Part part = msg.getPart(msg.getQName().getLocalPart()); + if (part == null) { + // bare parameter style + part = msg.getPart("arg0"); + return bareElement(part.getElementName()); + } else { + return schemaElement(part.getElementName()); + } + } + + protected String parameterType(String methodName) { + return parameterElement(methodName).getAttribute("type"); + } + + protected Element returnElement(String methodName) { + Operation op = portType.getOperation(methodName, null, null); + Output out = op.getOutput(); + Message msg = out.getMessage(); + Part part = msg.getPart(msg.getQName().getLocalPart()); + QName elementQName = part.getElementName(); + return schemaElement(elementQName); + } + + protected String returnType(String methodName) { + return returnElement(methodName).getAttribute("type"); + } + + protected Element faultElement(String methodName, String faultName) { + Operation op = portType.getOperation(methodName, null, null); + Fault fault = op.getFault(faultName); + Message msg = fault.getMessage(); + Part part = msg.getPart(msg.getQName().getLocalPart()); + QName elementQName = part.getElementName(); + return schemaElement(elementQName); + } + + protected String faultType(String methodName, String faultName) { + return faultElement(methodName, faultName).getAttribute("type"); + } + + private Element bareElement(QName elementQName) { + // find schema definition for wrapper element + Element schema = schemaMap.get(elementQName.getNamespaceURI()); + + // find namespace prefixes for this schema definition + NamedNodeMap attrNodes = schema.getAttributes(); + for (int i = 0; i < attrNodes.getLength(); i++) { + Attr attr = (Attr)attrNodes.item(i); + String attrName = attr.getName(); + if (attrName.startsWith("xmlns:")) { + prefixMap.put(attrName.substring(6), attr.getValue()); + } + } + + // find wrapper element definition in schema + String elementName = elementQName.getLocalPart(); + Element wrapper = null; + NodeList childNodes = schema.getElementsByTagNameNS(SCHEMA_NS, "element"); + for (int i = 0; i < childNodes.getLength(); i++) { + Node childNode = childNodes.item(i); + if (childNode instanceof Element) { + String name = ((Element)childNode).getAttribute("name"); + if (elementName.equals(name)) { + wrapper = (Element)childNode; + break; + } + } + } + return wrapper; + } + + private Element schemaElement(QName elementQName) { + Element wrapper = bareElement(elementQName); + + // find type definition for wrapper element + String typeName = wrapper.getAttribute("type"); + Element wrapperType = null; + if ("".equals(typeName)) { + NodeList childNodes = wrapper.getElementsByTagNameNS(SCHEMA_NS, "complexType"); + wrapperType = (Element)childNodes.item(0); + } else { + wrapperType = typeDefinition(typeName); + } + + return firstChild(wrapperType); + } + + protected Element typeDefinition(String typeName) { + String typePrefix = typeName.substring(0, typeName.indexOf(":")); + String typeLocalName = typeName.substring(typeName.indexOf(":") + 1); + Element typeSchema = schemaMap.get(prefixMap.get(typePrefix)); + Element typeElement = null; + NodeList childNodes = typeSchema.getElementsByTagNameNS(SCHEMA_NS, "complexType"); + for (int i = 0; i < childNodes.getLength(); i++) { + Node childNode = childNodes.item(i); + if (childNode instanceof Element) { + String name = ((Element)childNode).getAttribute("name"); + if (typeLocalName.equals(name)) { + typeElement = (Element)childNode; + break; + } + } + } + return typeElement; + } + + protected Element firstChild(Element complexType) { + // find xs:sequence child element + NodeList childNodes = complexType.getElementsByTagNameNS(SCHEMA_NS, "sequence"); + Element sequence = (Element)childNodes.item(0); + + // find first xs:element child element + childNodes = sequence.getElementsByTagNameNS(SCHEMA_NS, "element"); + return (Element)childNodes.item(0); + } + + protected Element extensionElement(Element complexType) { + // find xs:complexContent child element + NodeList childNodes = complexType.getElementsByTagNameNS(SCHEMA_NS, "complexContent"); + Element complexContent = (Element)childNodes.item(0); + + // find first xs:extension child element + childNodes = complexContent.getElementsByTagNameNS(SCHEMA_NS, "extension"); + return (Element)childNodes.item(0); + } + + private static void readWSDL(String componentName, String serviceName) throws Exception { + WSDLReader wsdlReader = WSDLFactory.newInstance().newWSDLReader(); + wsdlReader.setFeature("javax.wsdl.verbose",false); + wsdlReader.setFeature("javax.wsdl.importDocuments",true); + + Definition definition = wsdlReader.readWSDL("http://localhost:8085/" + serviceName + "?wsdl"); + assertNotNull(definition); + + // find portType + Service service = definition.getService(new QName("http://datatypes/", componentName+'_'+serviceName)); + Port port = service.getPort(serviceName + "SOAP11Port"); + Binding binding = port.getBinding(); + portType = binding.getPortType(); + + // find schema definitions + Types types = definition.getTypes(); + schemaMap = new HashMap(); + for (Object ext : types.getExtensibilityElements()) { + ExtensibilityElement extElement = (ExtensibilityElement)ext; + if (SCHEMA_QNAME.equals(extElement.getElementType())) { + if (extElement instanceof Schema) { + Element schemaElement = ((Schema)extElement).getElement(); + schemaMap.put(schemaElement.getAttribute("targetNamespace"), schemaElement); + } + } + } + } + + /* + * Used for debugging DOM problems + */ + private void printDOM(Node node){ + try { + Transformer transformer = TransformerFactory.newInstance().newTransformer(); + Source source = new DOMSource(node); + Result result = new StreamResult(System.out); + transformer.transform(source, result); + } catch (Exception ex){ + ex.printStackTrace(); + } + } + + protected static void start(String componentName, String serviceName) throws Exception { + WSDLServiceGenerator.printWSDL = printWSDL; + node = TuscanyRuntime.newInstance().createNode("default"); + node.installContribution("datatypescontrib", "target/classes", null, null); + node.startComposite("datatypescontrib", "DataTypes.composite"); + printWSDL = false; // print WSDL once only + readWSDL(componentName, serviceName); + } + + protected static void stop() throws Exception { + node.stop(); + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DataTypesTestCase.java b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DataTypesTestCase.java new file mode 100644 index 0000000000..1e83fe3435 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DataTypesTestCase.java @@ -0,0 +1,186 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 datatypes; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.w3c.dom.Element; +import static org.junit.Assert.assertEquals; + +/** + * Test ?wsdl works and that the returned WSDL is correct + * + * @version $Rev: 814373 $ $Date: 2009-09-13 19:06:29 +0100 (Sun, 13 Sep 2009) $ + */ +public class DataTypesTestCase extends BaseFramework { + + @Test + public void testSimpleInt() throws Exception { + assertEquals("xs:int", parameterType("testSimpleInt")); + } + + @Test + public void testSimpleArrayInt() throws Exception { + Element paramElement = parameterElement("testSimpleArrayInt"); + assertEquals("xs:int", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testSimpleMultiArrayInt() throws Exception { + Element paramElement = parameterElement("testSimpleMultiArrayInt"); + // prefix name can vary, so compare only the fixed parts + assertEquals("ns", paramElement.getAttribute("type").substring(0, 2)); + assertEquals(":intArray", paramElement.getAttribute("type").substring(3)); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testSimpleMulti3ArrayInt() throws Exception { + Element paramElement = parameterElement("testSimpleMulti3ArrayInt"); + // prefix name can vary, so compare only the fixed parts + assertEquals("ns", paramElement.getAttribute("type").substring(0, 2)); + assertEquals(":intArrayArray", paramElement.getAttribute("type").substring(3)); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testList() throws Exception { + Element paramElement = parameterElement("testList"); + assertEquals("xs:anyType", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testSimpleListString() throws Exception { + Element paramElement = parameterElement("testSimpleListString"); + assertEquals("xs:string", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testReturnSimpleListString() throws Exception { + Element retElement = returnElement("testReturnSimpleListString"); + assertEquals("xs:string", retElement.getAttribute("type")); + assertEquals("unbounded", retElement.getAttribute("maxOccurs")); + } + + @Test + public void testListByteArray() throws Exception { + Element paramElement = parameterElement("testListByteArray"); + assertEquals("xs:base64Binary", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testListWildcard() throws Exception { + Element paramElement = parameterElement("testListWildcard"); + assertEquals("xs:anyType", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } + + @Test + public void testComplex() throws Exception { + String paramType = parameterType("testComplex"); + assertEquals("tns:complexNumber", paramType); + assertEquals("xs:double", firstChild(typeDefinition(paramType)).getAttribute("type")); + } + + @Test + public void testOtherPackage() throws Exception { + String paramType = parameterType("testOtherPackage"); + // prefix name can vary, so compare only the fixed parts + assertEquals("ns", paramType.substring(0, 2)); + assertEquals(":otherPojo", paramType.substring(3)); + assertEquals("xs:double", firstChild(typeDefinition(paramType)).getAttribute("type")); + } + + @Test + public void testByteArray() throws Exception { + assertEquals("xs:base64Binary", parameterType("testByteArray")); + } + + @Test + public void testBaseExtension() throws Exception { + String paramType = parameterType("testBaseExtension"); + assertEquals("tns:extClass", paramType); + assertEquals("tns:baseClass", extensionElement(typeDefinition(paramType)).getAttribute("base")); + } + + @Test + public void testServiceReference() throws Exception { + assertEquals("xs:anyType", parameterType("testServiceReference")); + } + + @Test + public void testException() throws Exception { + assertEquals("xs:string", faultType("testException", "Exception")); + } + + @Test + public void testDynamicSDO() throws Exception { + assertEquals("xs:anyType", returnType("testDynamicSDO")); + } + + @Test + public void testWebParamSDO() throws Exception { + Element paramElement = parameterElement("testWebParamSDO"); + assertEquals("foo", paramElement.getAttribute("name")); + assertEquals("xs:anyType", paramElement.getAttribute("type")); + } + + @Test + public void testWebParamSDOArray() throws Exception { + Element paramElement = parameterElement("testWebParamSDOArray"); + assertEquals("foo", paramElement.getAttribute("name")); + assertEquals("xs:anyType", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } +/* + + @Test + public void testWebParamBare() throws Exception { + Element paramElement = parameterElement("testWebParamBare"); + assertEquals("simpleInt", paramElement.getAttribute("name")); + assertEquals("xs:int", paramElement.getAttribute("type")); + } + + @Test + @Ignore + public void testWebParamBareArray() throws Exception { + Element paramElement = parameterElement("testWebParamBareArray"); + assertEquals("arrayInt", paramElement.getAttribute("name")); + assertEquals("xs:int", paramElement.getAttribute("type")); + assertEquals("unbounded", paramElement.getAttribute("maxOccurs")); + } +*/ + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + BaseFramework.start("DataTypes", "DataTypes"); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + BaseFramework.stop(); + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DynamicSDOTestCase.java b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DynamicSDOTestCase.java new file mode 100644 index 0000000000..94d7765466 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/datatypes/DynamicSDOTestCase.java @@ -0,0 +1,81 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 datatypes; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.w3c.dom.Element; +import static org.junit.Assert.assertEquals; + +/** + * Test ?wsdl works and that the returned WSDL is correct + * + * @version $Rev: 814373 $ $Date: 2009-09-13 19:06:29 +0100 (Sun, 13 Sep 2009) $ + */ +public class DynamicSDOTestCase extends BaseFramework { + + @Test + public void testGetMessage() throws Exception { + assertEquals("xs:base64Binary", returnType("getMessage")); + } + + @Test + public void testGetMessageList() throws Exception { + Element retElement = returnElement("getMessageList"); + assertEquals("xs:base64Binary", retElement.getAttribute("type")); + assertEquals("unbounded", retElement.getAttribute("maxOccurs")); + } + + @Test + public void testGetMessageSDO() throws Exception { + assertEquals("xs:anyType", returnType("getMessageSDO")); + } + + @Test + public void testGetMessageListSDOList() throws Exception { + Element retElement = returnElement("getMessageListSDOList"); + assertEquals("xs:anyType", retElement.getAttribute("type")); + assertEquals("unbounded", retElement.getAttribute("maxOccurs")); + } + + @Test + public void testGetMessageListSDOArr() throws Exception { + Element retElement = returnElement("getMessageListSDOArr"); + assertEquals("xs:anyType", retElement.getAttribute("type")); + assertEquals("unbounded", retElement.getAttribute("maxOccurs")); + } + + @Test + public void testGetMessageListSDOinSDO() throws Exception { + assertEquals("xs:anyType", returnType("getMessageListSDOinSDO")); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + BaseFramework.start("DynamicSDO", "GetDataServiceWithoutException"); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + BaseFramework.stop(); + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/SchemaCorrectionTestCase.java b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/SchemaCorrectionTestCase.java new file mode 100644 index 0000000000..39f5380a00 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/SchemaCorrectionTestCase.java @@ -0,0 +1,462 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 helloworld; + +import java.io.IOException; +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.xml.bind.JAXBContext; +import javax.xml.bind.JAXBException; +import javax.xml.bind.SchemaOutputResolver; +import javax.xml.bind.annotation.XmlSchema; +import javax.xml.namespace.QName; +import javax.xml.transform.Result; +import javax.xml.transform.Source; +import javax.xml.transform.Transformer; +import javax.xml.transform.TransformerException; +import javax.xml.transform.TransformerFactory; +import javax.xml.transform.dom.DOMResult; +import javax.xml.transform.dom.DOMSource; +import javax.xml.transform.stream.StreamResult; + +import org.apache.tuscany.sca.Node; +import org.apache.tuscany.sca.TuscanyRuntime; +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.databinding.jaxb.JAXBContextHelper; +import org.apache.tuscany.sca.databinding.jaxb.JAXBTypeHelper; +import org.apache.tuscany.sca.impl.NodeImpl; +import org.apache.tuscany.sca.interfacedef.java.jaxws.GeneratedClassLoader; +import org.apache.ws.commons.schema.XmlSchemaCollection; +import org.apache.ws.commons.schema.XmlSchemaComplexType; +import org.apache.ws.commons.schema.XmlSchemaElement; +import org.apache.ws.commons.schema.XmlSchemaGroupBase; +import org.apache.ws.commons.schema.XmlSchemaImport; +import org.apache.ws.commons.schema.XmlSchemaObject; +import org.apache.ws.commons.schema.XmlSchemaObjectCollection; +import org.apache.ws.commons.schema.XmlSchemaSerializer.XmlSchemaSerializerException; +import org.junit.After; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.w3c.dom.Document; + +import anotherpackage.BBean; +import anotherpackage.CBean; +import yetanotherpackage.DBean; + +/** + * Tests that the helloworld server is available + */ +@Ignore("Just some scratch code I don't want to loose just yet") +public class SchemaCorrectionTestCase{ + + private Node node; + + @Before + public void startServer() throws Exception { + node = TuscanyRuntime.newInstance().createNode("default"); + } + + @Test + public void testSchemaGen() throws JAXBException, IOException, TransformerException, Exception { + ExtensionPointRegistry extensionPointRegistry = ((NodeImpl)node).getExtensionPointRegistry(); + JAXBTypeHelper typeHelper = new JAXBTypeHelper(extensionPointRegistry); + JAXBContextHelper contextHelper = new JAXBContextHelper(extensionPointRegistry); + + //typeHelper.getSchemaDefinitions(factory, resolver, intf); + + Package pkg = CBean.class.getPackage(); + String pkgName = pkg.getName(); + Annotation[] pkgAnnotations = pkg.getAnnotations(); + boolean genPkgInfo = true; + + for (Annotation annotation : pkgAnnotations){ + if (annotation instanceof XmlSchema){ + XmlSchema schemaAnnotation = (XmlSchema)annotation; + if (schemaAnnotation.namespace() != null){ + genPkgInfo = false; + break; + } + } + } + + JAXBContext context = null; + + if (genPkgInfo){ + System.out.println("There is no package info so generate one"); +/* Can gen the annotation but then what? + Class genClass = generatePackageInfo(pkgName, "http://sometestsnamespace"); + + Package pkgGen = aClass.getPackage(); + String pkgGenName = pkg.getName(); + Annotation[] pkgGenAnnotations = pkg.getAnnotations(); + XmlSchema schemaAnnotation = null; + + for (Annotation annotation : pkgGenAnnotations){ + if (annotation instanceof XmlSchema){ + schemaAnnotation = (XmlSchema)annotation; + } + } + + pkgAnnotations = pkgGenAnnotations; +*/ + +/* Can't pass the generarted package into JAXB. It has to + * be properly referenced as a package of a class you're trying + * generate. + Class[] classes = {aClass, genClass}; + context = contextHelper.createJAXBContext(classes); +*/ + } else { + System.out.println("There is package info"); + } + + Class[] classes = {ABean.class, BBean.class, CBean.class, DBean.class}; + context = contextHelper.createJAXBContext(classes); + + DOMResolverImpl resolver = new DOMResolverImpl(); + context.generateSchema(resolver); + + String toNamespace = null; + String fromNamespace = null; + Document toDocument = null; + Document fromDocument = null; + Map otherDocuments = new HashMap(); + + Map results = resolver.getResults(); + for (Map.Entry entry : results.entrySet()) { + System.out.println("\nPREMERGE NS: " + entry.getKey()); + if (entry.getKey().equals("")){ + fromNamespace = entry.getKey(); + fromDocument = (Document)entry.getValue().getNode(); + } else if (entry.getKey().equals("http://helloworld/")){ + toNamespace = entry.getKey(); + toDocument = (Document)entry.getValue().getNode(); + } else { + otherDocuments.put(entry.getKey(), (Document)entry.getValue().getNode()); + } + System.out.println("PREMERGE XSD: "); + printDOM((Document)entry.getValue().getNode()); + } + + // merge no-namespace XSD into default namespace XSD + System.out.println("\nPOSTMERGE"); + List mergedDocuments = mergeSchema(fromNamespace, fromDocument, toNamespace, toDocument, otherDocuments.values()); + + for (Document mergedDocument : mergedDocuments){ + System.out.println("\n"); + printDOM(mergedDocument); + } + } + + @After + public void stopServer() throws Exception { + + } + + private static class DOMResolverImpl extends SchemaOutputResolver { + private Map results = new HashMap(); + + @Override + public Result createOutput(String ns, String file) throws IOException { + DOMResult result = new DOMResult(); + // TUSCANY-2498: Set the system id to "" so that the xsd:import doesn't produce + // an illegal schemaLocation attr + result.setSystemId(""); + results.put(ns, result); + return result; + } + + public Map getResults() { + return results; + } + } + + private void printDOM(Document document)throws TransformerException { + Transformer transformer = TransformerFactory.newInstance().newTransformer(); + Source source = new DOMSource(document); + Result output = new StreamResult(System.out); + transformer.transform(source, output); + } + + public Class generatePackageInfo(String packageName, String namespace) throws Exception{ + String className = packageName + ".package-info"; + String internalClassName = className.replace('.', '/'); + + PackageInfoGenerator pig = new PackageInfoGenerator(); + + byte[] byteCode = pig.dump(internalClassName, namespace); + + GeneratedClassLoader classLoader = new GeneratedClassLoader(this.getClass().getClassLoader()); + return classLoader.getGeneratedClass(className, byteCode); + } + + + public class PackageInfoGenerator implements Opcodes { + + public byte[] dump (String internalClassName, String namespace) throws Exception { + ClassWriter cw = new ClassWriter(0); + FieldVisitor fv; + MethodVisitor mv; + AnnotationVisitor av0; + + cw.visit(V1_6, ACC_ABSTRACT + ACC_INTERFACE + ACC_SYNTHETIC, internalClassName, null, "java/lang/Object", null); + + cw.visitSource("package-info.java", null); + + + av0 = cw.visitAnnotation("Ljavax/xml/bind/annotation/XmlSchema;", true); + av0.visit("namespace", namespace); + av0.visitEnd(); + + cw.visitEnd(); + + return cw.toByteArray(); + } + } + + private List mergeSchema(String fromNamespace, Document fromDoc, String toNamespace, Document toDoc, Collection relatedDocs) throws XmlSchemaSerializerException{ + // Read all the input DOMs into a schema collection so we can maniuplate them + XmlSchemaCollection schemaCollection = new XmlSchemaCollection(); + schemaCollection.read(fromDoc.getDocumentElement()); + schemaCollection.read(toDoc.getDocumentElement()); + + for(Document doc : relatedDocs){ + schemaCollection.read(doc.getDocumentElement()); + } + + org.apache.ws.commons.schema.XmlSchema fromSchema = null; + org.apache.ws.commons.schema.XmlSchema toSchema = null; + List relatedSchema = new ArrayList(); + org.apache.ws.commons.schema.XmlSchema schemas[] = schemaCollection.getXmlSchemas(); + for (int i=1; i < schemas.length; i++){ + org.apache.ws.commons.schema.XmlSchema schema = schemas[i]; + if (schema.getTargetNamespace() == null){ + fromSchema = schema; + } else if (schema.getTargetNamespace().equals(toNamespace)){ + toSchema = schema; + relatedSchema.add(schema); + } else { + relatedSchema.add(schema); + } + } + + // copy all the FROM items to the TO schema + XmlSchemaObjectCollection fromItems = fromSchema.getItems(); + XmlSchemaObjectCollection toItems = toSchema.getItems(); + + Iterator iter = fromItems.getIterator(); + while(iter.hasNext()){ + // don't copy import for TO namespace + XmlSchemaObject obj = iter.next(); + if (obj instanceof XmlSchemaImport && + ((XmlSchemaImport)obj).getNamespace().equals(toNamespace)){ + // do nothing + } else { + toItems.add(obj); + // correct any references to the item just moved + fixUpMovedTypeReferences(fromNamespace, toNamespace, obj, relatedSchema); + } + } + + // Create the list of resulting DOMs + List resultDocs = new ArrayList(); + + for (org.apache.ws.commons.schema.XmlSchema related : relatedSchema){ + resultDocs.add(related.getSchemaDocument()); + } + + return resultDocs; + } + + public void fixUpMovedTypeReferences(String fromNamespace, String toNamespace, XmlSchemaObject fixUpObj, List relatedSchema){ + + if (!(fixUpObj instanceof XmlSchemaComplexType)){ + return; + } + + for (org.apache.ws.commons.schema.XmlSchema schema : relatedSchema){ + int importRemoveIndex = -1; + for (int i = 0; i < schema.getItems().getCount(); i++){ + XmlSchemaObject obj = schema.getItems().getItem(i); + + // if this is not the TO schema then fix up all references + // to items moved to the TO schema + if(!schema.getTargetNamespace().equals(toNamespace)){ + processXMLSchemaObject(toNamespace, obj, fixUpObj); + } + + // remove FROM imports + if (obj instanceof XmlSchemaImport && + ((XmlSchemaImport)obj).getNamespace().equals(fromNamespace)){ + importRemoveIndex = i; + } + } + + if (importRemoveIndex >= 0){ + schema.getItems().removeAt(importRemoveIndex); + } + } + } + + public void processXMLSchemaObject(String toNamespace, XmlSchemaObject obj, XmlSchemaObject fixUpObj){ + if (obj instanceof XmlSchemaComplexType){ + processXMLSchemaObject(toNamespace, ((XmlSchemaComplexType)obj).getParticle(), fixUpObj); + } else if (obj instanceof XmlSchemaElement){ + XmlSchemaElement element = (XmlSchemaElement)obj; + if(element.getSchemaType() == fixUpObj){ + QName name = element.getSchemaTypeName(); + QName newName = new QName(toNamespace, name.getLocalPart()); + element.setSchemaTypeName(newName); + } + ((XmlSchemaElement)obj).getSchemaType(); + } else if (obj instanceof XmlSchemaGroupBase){ + XmlSchemaObjectCollection items = ((XmlSchemaGroupBase)obj).getItems(); + Iterator iter = items.getIterator(); + while(iter.hasNext()){ + processXMLSchemaObject(toNamespace, iter.next(), fixUpObj); + } + } + } + +/* + private List mergeSchema(String fromNamespace, Document fromDoc, String toNamespace, Document toDoc, Collection relatedDocs) throws XmlSchemaSerializerException{ + XmlSchemaCollection schemaCollection = new XmlSchemaCollection(); + schemaCollection.read(fromDoc.getDocumentElement()); + schemaCollection.read(toDoc.getDocumentElement()); + + for(Document doc : relatedDocs){ + schemaCollection.read(doc.getDocumentElement()); + } + + org.apache.ws.commons.schema.XmlSchema fromSchema = null; + org.apache.ws.commons.schema.XmlSchema toSchema = null; + List relatedSchema = new ArrayList(); + org.apache.ws.commons.schema.XmlSchema schemas[] = schemaCollection.getXmlSchemas(); + for (int i=1; i < schemas.length; i++){ + org.apache.ws.commons.schema.XmlSchema schema = schemas[i]; + if (schema.getTargetNamespace() == null){ + fromSchema = schema; + } else if (schema.getTargetNamespace().equals(toNamespace)){ + toSchema = schema; + } else { + relatedSchema.add(schema); + } + } + + // add all the FROM items to the TO schema + XmlSchemaObjectCollection fromItems = fromSchema.getItems(); + XmlSchemaObjectCollection toItems = toSchema.getItems(); + + Iterator iter = fromItems.getIterator(); + while(iter.hasNext()){ + // don't copy import for TO namespace + XmlSchemaObject obj = iter.next(); + if (obj instanceof XmlSchemaImport && + ((XmlSchemaImport)obj).getNamespace().equals(toNamespace)){ + // do nothing + } else { + toItems.add(obj); + fixUpMovedTypeReferences(fromNamespace, toNamespace, obj, relatedSchema); + } + } + + // remove the FROM namespace from TO schema includes list + XmlSchemaObjectCollection toIncludes = toSchema.getIncludes(); + XmlSchemaImport schemaImport = null; + iter = toIncludes.getIterator(); + while(iter.hasNext()){ + XmlSchemaImport tmpImport = (XmlSchemaImport)iter.next(); + if (tmpImport.getNamespace().equals(fromNamespace)){ + schemaImport = tmpImport; + break; + } + } + + if (schemaImport != null){ + toIncludes.remove(schemaImport); + toItems.remove(schemaImport); + } + + List resultDocs = new ArrayList(); + resultDocs.add(toSchema.getSchemaDocument()); + + for (org.apache.ws.commons.schema.XmlSchema related : relatedSchema){ + resultDocs.add(related.getSchemaDocument()); + } + + return resultDocs; + } + + public void fixUpMovedTypeReferences(String fromNamespace, String toNamespace, XmlSchemaObject fixUpObj, List relatedSchema){ + for (org.apache.ws.commons.schema.XmlSchema schema : relatedSchema){ + XmlSchemaObjectCollection items = schema.getItems(); + Iterator iter = items.getIterator(); + XmlSchemaImport importToRemove = null; + while(iter.hasNext()){ + XmlSchemaObject obj = iter.next(); + processXMLSchemaObject(toNamespace, obj, fixUpObj); + + // remote FROM imports + if (obj instanceof XmlSchemaImport && + ((XmlSchemaImport)obj).getNamespace().equals(fromNamespace)){ + importToRemove = (XmlSchemaImport)obj; + } + } + + if (importToRemove != null){ + items.remove(importToRemove); + schema.getIncludes().remove(importToRemove); + } + } + } + + public void processXMLSchemaObject(String toNamespace, XmlSchemaObject obj, XmlSchemaObject fixUpObj){ + if (obj instanceof XmlSchemaComplexType){ + processXMLSchemaObject(toNamespace, ((XmlSchemaComplexType)obj).getParticle(), fixUpObj); + } else if (obj instanceof XmlSchemaElement){ + XmlSchemaElement element = (XmlSchemaElement)obj; + if(element.getSchemaType() == fixUpObj){ + QName name = element.getSchemaTypeName(); + QName newName = new QName(toNamespace, name.getLocalPart()); + element.setSchemaTypeName(newName); + } + ((XmlSchemaElement)obj).getSchemaType(); + } else if (obj instanceof XmlSchemaGroupBase){ + XmlSchemaObjectCollection items = ((XmlSchemaGroupBase)obj).getItems(); + Iterator iter = items.getIterator(); + while(iter.hasNext()){ + processXMLSchemaObject(toNamespace, iter.next(), fixUpObj); + } + } + } + */ + +} \ No newline at end of file diff --git a/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/WSDLGenTestCase.java b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/WSDLGenTestCase.java new file mode 100644 index 0000000000..6954a8a7ac --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/testing/itest/ws/wsdlgen/src/test/java/helloworld/WSDLGenTestCase.java @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 helloworld; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertNotNull; +import static junit.framework.Assert.fail; + +import java.io.IOException; +import java.net.URL; + +import javax.xml.namespace.QName; +import javax.xml.ws.Service; + +import org.apache.tuscany.sca.Node; +import org.apache.tuscany.sca.TuscanyRuntime; +import org.junit.After; +import org.junit.Before; +import org.junit.Ignore; +import org.junit.Test; +import org.oasisopen.sca.NoSuchServiceException; + +import yetanotherpackage.DBean; + +import anotherpackage.BBean; + +/** + * Tests that the helloworld server is available + */ +public class WSDLGenTestCase{ + + private Node node; + + @Before + public void startServer() throws Exception { + node = TuscanyRuntime.newInstance().createNode("default"); + node.installContribution("helloworld", "target/classes", null, null); + node.startComposite("helloworld", "helloworld.composite"); + } + + @Ignore + @Test + public void testWaitForInput() { + System.out.println("Press a key to end"); + try { + System.in.read(); + } catch (Exception ex) { + } + System.out.println("Shutting down"); + } + + @Test + public void testComponentSCA() throws IOException, NoSuchServiceException { + HelloWorldService helloWorldService = node.getService(HelloWorldService.class, "HelloWorldServiceComponent/HelloWorldService"); + assertNotNull(helloWorldService); + + HelloWorldService helloWorldClient = node.getService(HelloWorldService.class, "HelloWorldClientComponent/HelloWorldService"); + assertNotNull(helloWorldClient); + + assertEquals("Hello Smith", helloWorldService.getGreetings("Smith")); + assertEquals("Hello Hello Smith", helloWorldClient.getGreetings("Smith")); + + BBean bbean = new BBean(); + bbean.setField1("1"); + bbean.setField2("2"); + + DBean abean = new DBean(); + abean.setField1("3"); + abean.setField2("4"); + abean.setField3(bbean); + + assertEquals("Hello Hello 3 4 1 2", helloWorldClient.getGreetingsDBean(abean)); + + try { + helloWorldClient.getGreetingsException("Fred"); + fail("exception not returned"); + } catch(Exception ex) { + + } + } + + @Test + public void testComponentJAXWSwsgen() throws IOException { + + // talk to the service using JAXWS with WSDL generated from this service using wsgen + // the idea here is to demonstrate that the service is providing a JAXWS compliant + // interface + QName serviceName = new QName("http://helloworld/", "HelloWorldImplService"); + QName portName = new QName("http://helloworld/", "HelloWorldImplPort"); + URL wsdlLocation = this.getClass().getClassLoader().getResource("jaxws/wsgen/wsdl/HelloWorldImplService.wsdl"); + Service webService = Service.create( wsdlLocation, serviceName ); + HelloWorldService wsProxy = (HelloWorldService) webService.getPort(portName, HelloWorldService.class); + + assertEquals("Hello Fred", wsProxy.getGreetings("Fred")); + + BBean bbean = new BBean(); + bbean.setField1("1"); + bbean.setField2("2"); + + DBean abean = new DBean(); + abean.setField1("3"); + abean.setField2("4"); + abean.setField3(bbean); + + assertEquals("Hello 3 4 1 2", wsProxy.getGreetingsDBean(abean)); + + String byteArrayString = "Hello World"; + assertEquals(byteArrayString, new String(wsProxy.getGreetingsByteArray(byteArrayString.getBytes()))); + + try { + wsProxy.getGreetingsException("Fred"); + fail("exception not returned"); + } catch(Exception ex) { + + } + } + + @Test + public void testComponentJAXWStuscanygen() throws IOException { + // talk to the service using JAXWS with WSDL generated from this service used Tuscany's ?wsdl + // the idea here is to demonstrate that the service is providing a JAXWS compliant + // WSDL + QName serviceName = new QName("http://helloworld/", "HelloWorldServiceComponent_HelloWorldService"); + QName portName = new QName("http://helloworld/", "HelloWorldServiceSOAP11Port"); + URL wsdlLocation = new URL("http://localhost:8085/HelloWorldServiceComponent?wsdl"); + Service webService = Service.create( wsdlLocation, serviceName ); + HelloWorldService wsProxy = (HelloWorldService) webService.getPort(portName, HelloWorldService.class); + + assertEquals("Hello Fred", wsProxy.getGreetings("Fred")); + + BBean bbean = new BBean(); + bbean.setField1("1"); + bbean.setField2("2"); + + DBean abean = new DBean(); + abean.setField1("3"); + abean.setField2("4"); + abean.setField3(bbean); + + assertEquals("Hello 3 4 1 2", wsProxy.getGreetingsDBean(abean)); + + String byteArrayString = "Hello World"; + assertEquals(byteArrayString, new String(wsProxy.getGreetingsByteArray(byteArrayString.getBytes()))); + + try { + wsProxy.getGreetingsException("Fred"); + fail("exception not returned"); + } catch(Exception ex) { + + } + } + + // Differences between JAXWS WSDL (J) and Tuscany WSDL (T) + // + // Service name + // J/ HelloWorldImplService T/ HelloWorldService + // + // Port name + // J/ HelloWorldImplPort T/ HelloWorldServiceSOAP11Port + + @After + public void stopServer() throws Exception { + if (node != null) { + node.stop(); + } + } + +} -- cgit v1.2.3