DescriptionFactoryImplTests.java

/*
 * 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 org.apache.axis2.jaxws.description.impl;

import junit.framework.TestCase;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.jaxws.ClientConfigurationFactory;
import org.apache.axis2.jaxws.description.EndpointDescription;
import org.apache.axis2.jaxws.description.ServiceDescription;
import org.apache.axis2.jaxws.description.builder.CustomAnnotationInstance;
import org.apache.axis2.jaxws.description.builder.CustomAnnotationProcessor;
import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite;
import org.apache.axis2.jaxws.description.builder.converter.JavaClassToDBCConverter;
import org.apache.axis2.jaxws.description.impl.DescriptionFactoryImpl;
import org.apache.axis2.jaxws.description.validator.EndpointDescriptionValidator;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType;
import org.apache.axis2.metadata.registry.MetadataFactoryRegistry;

import javax.jws.WebService;
import javax.xml.namespace.QName;
import java.io.File;
import java.io.InputStream;
import java.lang.annotation.ElementType;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DescriptionFactoryImplTests extends TestCase {
    
    private static final String namespaceURI =
            "http://org.apache.axis2.jaxws.description.ServiceDescriptionTests";
    private static final String localPart = "EchoService";
    private static final QName serviceQName = new QName(namespaceURI, localPart);

    
    public void testServiceDescriptionCaching() {        
        QName uniqueQName = new QName(namespaceURI, localPart + "_testValidServiceSubclass");
        
        ServiceDescription desc1 = 
            DescriptionFactoryImpl.createServiceDescription(null, uniqueQName, ServiceSubclass.class);
                  
        /*
        int size = 5;
        ServiceDescription desc2; 
        for (int i = 0; i < size; i++) {
            desc2 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName, ServiceSubclass.class);
            assertTrue("service description was not reused", desc1 == desc2);
        } 
        */    
    }      

    public void testClearServiceDescriptionCache() throws Exception {        
        QName uniqueQName1 = new QName(namespaceURI, localPart + "_testClearCache1");
        QName uniqueQName2 = new QName(namespaceURI, localPart + "_testClearCache2");
  
//        // the ClientConfigFactory instance is stored DescriptionFactoryImpl clientConfigFactory 
//        // field and for this test we need to clear it, so that a custom version of 
//        // ClientConfigurationFactory can be used.
//        resetClientConfigFactory();
        
        // install caching factory        
        ClientConfigurationFactory oldFactory = 
            (ClientConfigurationFactory)MetadataFactoryRegistry.getFactory(ClientConfigurationFactory.class);
        CachingClientContextFactory newFactory = new CachingClientContextFactory();
        MetadataFactoryRegistry.setFactory(ClientConfigurationFactory.class, newFactory);
        
        try {
            ServiceDescription desc1 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName1, ServiceSubclass.class);
                        
            ServiceDescription desc2 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName1, ServiceSubclass.class);
            
            newFactory.reset();
            
            ServiceDescription desc3 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName2, ServiceSubclass.class);
            
            assertTrue(desc1 == desc2);
            assertTrue(desc1 != desc3);
                        
            // should clear one
            DescriptionFactoryImpl.clearServiceDescriptionCache(desc2.getAxisConfigContext());
            
            ServiceDescription desc4 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName1, ServiceSubclass.class);
                        
            ServiceDescription desc5 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName2, ServiceSubclass.class);
            
            assertTrue(desc1 != desc4);
            assertTrue(desc3 == desc5);
                       
            // should clear both
            DescriptionFactoryImpl.clearServiceDescriptionCache();
            
            ServiceDescription desc6 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName1, ServiceSubclass.class);
            
            ServiceDescription desc7 = 
                DescriptionFactoryImpl.createServiceDescription(null, uniqueQName2, ServiceSubclass.class);
            
            assertTrue(desc4 != desc6);
            assertTrue(desc3 != desc7);
            
            // this should do nothing
            DescriptionFactoryImpl.clearServiceDescriptionCache(null);
            
        } finally {
            // restore old factory by updating the registry THEN clearing the cached factory
            // so it is retrieved from the table again.
            MetadataFactoryRegistry.setFactory(ClientConfigurationFactory.class, oldFactory);
//            resetClientConfigFactory();
        }                          
    }
    
    public void testCustomAnnotationSupport() {
        JavaClassToDBCConverter converter = new JavaClassToDBCConverter(AnnotatedService.class);
        HashMap<String, DescriptionBuilderComposite> dbcMap = converter.produceDBC();
        DescriptionBuilderComposite dbc = dbcMap.get(AnnotatedService.class.getName());
        assertNotNull(dbc);
        SampleAnnotation sampleAnnotation = new SampleAnnotation();
        sampleAnnotation.setAnnotationClassName(Custom.class.getName());
        dbc.addCustomAnnotationInstance(sampleAnnotation);
        SampleAnnotationProcessor saProcessor = new SampleAnnotationProcessor();
        saProcessor.setAnnotationInstanceClassName(sampleAnnotation.getClass().getName());
        dbc.addCustomAnnotationProcessor(saProcessor);
        WebService webService = dbc.getWebServiceAnnot();
        assertNotNull(webService);
        String pn = webService.portName();
        String tns = webService.targetNamespace();
        assertNotNull(pn);
        assertNotNull(tns);
        QName portQName = new QName(tns, pn);
        List<ServiceDescription> sdList = DescriptionFactoryImpl.createServiceDescriptionFromDBCMap(dbcMap, null);
        assertNotNull(sdList);
        assertEquals(sdList.size(), 1);
        ServiceDescription sd = sdList.get(0);
        assertNotNull(sd);
        EndpointDescription ed = sd.getEndpointDescription(portQName);
        assertNotNull(ed);
        // for testing purposes we want to make a cast b/c some of the methods
        // we are accessing are protected in EndpointDescriptionImpl
        if(ed instanceof EndpointDescriptionImpl) {
            EndpointDescriptionImpl edImpl = (EndpointDescriptionImpl) ed;
            List<CustomAnnotationInstance> customAnnotationList = edImpl.getCustomAnnotationInstances();
            assertNotNull(customAnnotationList);
            assertEquals(customAnnotationList.size(), 1);
            CustomAnnotationInstance annotationInstance = customAnnotationList.get(0);
            assertNotNull(annotationInstance);
            assertEquals(annotationInstance.getClass().getName(), SampleAnnotation.class.getName());
            CustomAnnotationProcessor processor = edImpl.getCustomAnnotationProcessor(annotationInstance.getClass().getName());
            assertNotNull(processor);
            AxisService axisService = ed.getAxisService();
            assertNotNull(axisService);
            String name = (String) axisService.getParameterValue(SampleAnnotation.class.getName());
            assertNotNull(name);
            assertEquals(SampleAnnotationProcessor.class.getName(), name);
        }
    }
    
    public void testHandlerChainType() {
    	JavaClassToDBCConverter converter = new JavaClassToDBCConverter(AnnotatedService.class);
        HashMap<String, DescriptionBuilderComposite> dbcMap = converter.produceDBC();
        DescriptionBuilderComposite dbc = dbcMap.get(AnnotatedService.class.getName());
        assertNotNull(dbc);
        InputStream is = getXMLFileStream();
        assertNotNull(is);
        HandlerChainsType hct = DescriptionUtils.loadHandlerChains(is, this.getClass().getClassLoader());
        dbc.setHandlerChainsType(hct);
        List<ServiceDescription> sdList = DescriptionFactoryImpl.createServiceDescriptionFromDBCMap(dbcMap, null);
        assertNotNull(sdList);
        assertTrue(sdList.size() > 0);
        ServiceDescription sd = sdList.get(0);
        assertNotNull(sd.getEndpointDescriptions_AsCollection());
        Collection<EndpointDescription> edColl = sd.getEndpointDescriptions_AsCollection();
        assertNotNull(edColl);
        assertTrue(edColl.size() > 0);
        EndpointDescription ed = edColl.iterator().next();
        assertNotNull(ed);
        assertNotNull(ed.getHandlerChain());
    }
    
    /**
     * This will verify that properties are correctly copied from a DBC to an
     * EndpointDescription instance by a helper method in DescriptionFactoryImpl.
     */
    public void testSetPropertiesOnEndpointDesc() {
        
        // first get an EndpointDescription instance
        JavaClassToDBCConverter converter = new JavaClassToDBCConverter(AnnotatedService.class);
        HashMap<String, DescriptionBuilderComposite> dbcMap = converter.produceDBC();
        DescriptionBuilderComposite dbc = dbcMap.get(AnnotatedService.class.getName());
        assertNotNull(dbc);
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put("testKey", "testValue");
        dbc.setProperties(properties);
        List<ServiceDescription> sdList = DescriptionFactoryImpl.createServiceDescriptionFromDBCMap(dbcMap, null);
        assertNotNull(sdList);
        assertEquals(sdList.size(), 1);
        ServiceDescription sd = sdList.get(0);
        assertNotNull(sd);
        assertNotNull(dbc.getWebServiceAnnot());
        String pn = dbc.getWebServiceAnnot().portName();
        String tns = dbc.getWebServiceAnnot().targetNamespace();
        assertNotNull(pn);
        assertNotNull(tns);
        QName portQName = new QName(tns, pn);
        EndpointDescription ed = sd.getEndpointDescription(portQName);
        assertNotNull(ed);
        
        // now test the setPropertiesOnEndpointDesc method
        DescriptionFactoryImpl.setPropertiesOnEndpointDesc(ed, dbc);
        assertNotNull(ed.getProperty("testKey"));
        assertEquals(ed.getProperty("testKey"), "testValue");
        
    }
    
    private InputStream getXMLFileStream() {
    	InputStream is = null;
    	String configLoc = null;
        try {
            String sep = "/";
            configLoc = sep + "test-resources" + sep + "test-handler.xml";
            String baseDir = new File(System.getProperty("basedir",".")).getCanonicalPath();
            is = new File(baseDir + configLoc).toURL().openStream();
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    	return is;
    }
    
    
    private void resetClientConfigFactory() throws Exception {
        Field field = DescriptionFactoryImpl.class.getDeclaredField("clientConfigFactory");
        field.setAccessible(true);
        field.set(null, null);
    }
    
    private static class ServiceSubclass extends javax.xml.ws.Service {

        protected ServiceSubclass(URL wsdlDocumentLocation, QName serviceName) {
            super(wsdlDocumentLocation, serviceName);
        }
    }
    
    private static class CachingClientContextFactory extends ClientConfigurationFactory {
        ConfigurationContext context;
        
        public ConfigurationContext getClientConfigurationContext() {
            if (context == null) {
                context = super.getClientConfigurationContext();
            }
            System.out.println("Test version of CachingClientContextFactory: " + context);
            return context;
        }
        
        public void reset() {
            context = null;
        }
        
    }
    
    class SampleAnnotation implements CustomAnnotationInstance {

        private Map<String, Object> dataMap = new HashMap<String, Object>();
        
        private ElementType elementType;
        
        List<String> knownParamNames;
        
        private String annotationClassName;
        
        SampleAnnotation(List<String> knownParamNames) {
            this.knownParamNames = knownParamNames;
        }
        
        public void setAnnotationClassName(String annotationClassName) {
            this.annotationClassName = annotationClassName;
        }
        
        public String getAnnotationClassName() {
            return annotationClassName;
        }
        
        SampleAnnotation() {
            knownParamNames = new ArrayList<String>();
            knownParamNames.add("name");
        }
        
        public void addParameterData(String paramName, Object value) throws IllegalArgumentException {
            checkParamName(paramName);
            dataMap.put(paramName, value);
        }

        public Object getParameterData(String paramName) throws IllegalArgumentException {
            checkParamName(paramName);
            return dataMap.get(paramName);
        }
        
        public void setTarget(ElementType elementType) {
            this.elementType = elementType;
        }

        public ElementType getTarget() {
            return elementType;
        }
        
        private void checkParamName(String paramName) throws IllegalArgumentException {
            if(knownParamNames != null 
                    && 
                    !knownParamNames.isEmpty() 
                    && 
                    !knownParamNames.contains(paramName)) {
                throw new IllegalArgumentException("The parameter " + paramName +
                                " is an unknown parameter for the CustomAnnotation type.");
            }
        }
    }

    class SampleAnnotationProcessor implements CustomAnnotationProcessor {
        
        private String annotationInstanceClassName;

        public String getAnnotationInstanceClassName() {
            return annotationInstanceClassName;
        }
        
        public void setAnnotationInstanceClassName(String annotationInstanceClassName) {
            this.annotationInstanceClassName = annotationInstanceClassName;
        }

        public void processTypeLevelAnnotation(EndpointDescription ed, CustomAnnotationInstance annotation) {
                AxisService axisService = ed.getAxisService();
                if(axisService != null) {
                    try {
                        axisService.addParameter(SampleAnnotation.class.getName(), 
                                                 SampleAnnotationProcessor.class.getName());
                    }
                    catch(AxisFault af) {
                        // nothing here
                    }
                }
        }
        
    }

    @interface Custom {
        String name() default "";
    }

    @WebService(targetNamespace="http://org.apache.example", serviceName="AnnotatedService", portName="AnnotatedPort")
    @Custom(name="AnnotatedService")
    class AnnotatedService {
        public String echo(String echoString) {
            return echoString;
        }
    }
    
}