AbstractTagLibTestCase

/*
 * 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.myfaces.commons.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import junit.framework.TestCase;
import net.sf.maventaglib.checker.Tag;
import net.sf.maventaglib.checker.TagAttribute;
import net.sf.maventaglib.checker.Tld;
import net.sf.maventaglib.checker.TldParser;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.w3c.dom.Document;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Insures the following ...
 * <ul>
 * <li> Tag handlers have setters for all tag attributes</li>
 * <li> All tag handlers are in the classpath</li>
 * <li> Tag handlers do not appear in the TLD more than once</li>
 * <li> Tag handler attributes do not occur mare than once</li>
 * </ul>
 *
 * @author Dennis Byrne
 * @see http://maven-taglib.sourceforge.net/ for dependency download
 */

public abstract class AbstractTagLibTestCase extends TestCase
{
    private static Log log = LogFactory.getLog(AbstractTagLibTestCase.class);

    protected Tld[] tlds;

    protected String[] tldPaths;

    private ClassLoader classLoader = getClass().getClassLoader();

    /**
     * Unmarshall TLDs to an object model. TLDs are supplied by a subclass.
     */

    protected void setUp() throws Exception
    {

        if (tldPaths == null)
            throw new NullPointerException(
                    "tldPaths cannot point to null before setUp() is called");

        int length = tldPaths.length;

        if (length == 0)
            throw new IllegalStateException(
                    "tldPaths should have at least one resource path");

        tlds = new Tld[length];

        for (int t = 0; t < length; t++)
        {
            String name = tldPaths[t];

            InputStream stream = classLoader.getResourceAsStream(name);

            if (stream == null)
                throw new NullPointerException(
                        "couldn't get an input stream for " + name);

            tlds[t] = TldTestUtils.getTld(name, stream);
            stream.close();
        }
    }

    public void testUniqueTagTestCase() throws Exception
    {

        for (int lib = 0; lib < tlds.length; lib++)
        {
            Tld tld = tlds[lib];
            List tagNames = new ArrayList();
            Tag[] tags = tld.getTags();

            for (int t = 0; t < tags.length; t++)
            {
                Tag tag = tags[t];

                if (tag == null)
                    throw new NullPointerException("tag");

                String name = tag.getName();
                String msg = name + " found more than once in " + tldPaths[lib];
                assertFalse(msg, tagNames.contains(name));
                tagNames.add(name);
            } // end t
        } // end lib
    }

    public void testUniqueTagAttributes() throws Exception
    {

        for (int lib = 0; lib < tlds.length; lib++)
        {
            Tld tld = tlds[lib];
            Tag[] tags = tld.getTags();

            for (int t = 0; t < tags.length; t++)
            {

                Tag tag = tags[t];
                assertUniqueTagAttributes(tag, tldPaths[lib]);

            } // end t
        } // end lib
    }

    private void assertUniqueTagAttributes(final Tag tag, final String path)
    {

        List attributeNames = new ArrayList();
        TagAttribute[] atts = tag.getAttributes();
        String tagName = tag.getName();

        for (int a = 0; a < atts.length;)
        {

            TagAttribute att = atts[a++];
            String name = att.getAttributeName();
            String msg = " @" + name + " of " + path + ":" + tagName
                    + " is duplicated.";
            assertFalse(msg, attributeNames.contains(name));
            attributeNames.add(name);

        } // end a

    }

    /**
     * Make sure the class exists. Make sure there is a setter for each
     * attribute.
     */

    public void testSetters() throws Exception
    {

        for (int t = 0; t < tlds.length; t++)
        {
            Tld tld = tlds[t];
            Tag[] tags = tld.getTags();

            for (int s = 0; s < tags.length; s++)
            {
                Tag tag = tags[s];
                String filename = tld.getFilename();

                Object object = TldTestUtils.makeTagClassInstance(tag,
                        filename, classLoader);
                log.debug("filename = " + filename + " ; tag = "
                        + tag.getName());
                assertSetters(tag, filename, object);

            } // end for tag
        } // end for lib

    }

    private void assertSetters(final Tag tag, final String path,
            final Object object)
    {

        TagAttribute[] attributes = tag.getAttributes();
        String tagName = tag.getName();

        for (int a = 0; a < attributes.length; a++)
        {
            TagAttribute attribute = attributes[a];
            String name = attribute.getAttributeName();

            if (name == null || "".equals(name.trim()))
                throw new IllegalStateException(path + ":" + tagName
                        + " has a nameless attribute ");

            String msg = path + ":" + tagName + "@" + name + " exists, but "
                    + object.getClass().getName() + " has no setter.";

            assertTrue(msg, PropertyUtils.isWriteable(object, name));
        } // end for attributes

    }

    private static class DelegateEntityResolver implements EntityResolver
    {
        private EntityResolver _delegate;

        public DelegateEntityResolver(EntityResolver delegate)
        {
            this._delegate = delegate;
        }

        public InputSource resolveEntity(String publicId, String systemId)
                throws SAXException, IOException
        {
            if (publicId.equals("-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"))
            {
                return new InputSource(Thread.currentThread()
                        .getContextClassLoader().getResourceAsStream(
                                "META-INF/dtd/web-jsptaglibrary_1_2.dtd"));
            }
            else
            {
                return _delegate.resolveEntity(publicId, systemId);
            }
        }
    }

    private static class TldTestUtils
    {
        private static Log log = LogFactory.getLog(TldTestUtils.class);

        private static DocumentBuilderFactory dbf = DocumentBuilderFactory
                .newInstance();
        static
        {
            dbf.setNamespaceAware(false);
            dbf.setValidating(false);
        }

        public static Tld getTld(String name, InputStream stream)
                throws Exception
        {
            if (stream == null)
                log.error(" input stream is null ");

            DocumentBuilder db = dbf.newDocumentBuilder();
            db.setEntityResolver(new DelegateEntityResolver(null));
            Document doc = db.parse(stream);

            return TldParser.parse(doc, name);
        }

        public static Object makeTagClassInstance(Tag tag, String filename,
                ClassLoader classLoader) throws Exception
        {

            String clazzName = tag.getTagClass();

            if (clazzName == null || "".equals(clazzName.trim()))
                throw new NullPointerException(tag.getName()
                        + " is missing a tag class.");

            try
            {

                Class clazz = classLoader.loadClass(clazzName);
                return clazz.newInstance();

            }
            catch (ClassNotFoundException e)
            {
                throw new ClassNotFoundException(clazzName);
            }
            catch (IllegalAccessException ie)
            {
                throw new IllegalAccessException(clazzName);
            }
            catch (InstantiationException iste)
            {
                throw new InstantiationException(clazzName);
            }
        }
    }
}