/*
    * 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
    *
    *      https://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.commons.xml.secure;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.io.StringReader;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Properties;
  
  import javax.xml.XMLConstants;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.ErrorListener;
  import javax.xml.transform.Source;
  import javax.xml.transform.Templates;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.URIResolver;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.sax.SAXSource;
  import javax.xml.transform.sax.SAXTransformerFactory;
  import javax.xml.transform.sax.TemplatesHandler;
  import javax.xml.transform.sax.TransformerHandler;
  import javax.xml.transform.stream.StreamSource;
  
  import org.junit.jupiter.api.Tag;
  import org.junit.jupiter.api.Test;
  import org.xml.sax.InputSource;
  import org.xml.sax.XMLFilter;
  
  /**
   * Tests {@link SecureTransformerFactory}.
   */
  @Tag("trax")
  class SecureTransformerFactoryTest {
  
      private static class NullProductsFactory extends SAXTransformerFactory {
  
          private final SAXTransformerFactory delegate = (SAXTransformerFactory) TransformerFactory.newInstance();
  
          private final Map<String, Object> attributes = new HashMap<>();
  
          @Override
          public Source getAssociatedStylesheet(final Source source, final String media, final String title, final String charset)
                  throws TransformerConfigurationException {
              return delegate.getAssociatedStylesheet(source, media, title, charset);
          }
  
          @Override
          public Object getAttribute(final String name) {
              return attributes.get(name);
          }
  
          @Override
          public ErrorListener getErrorListener() {
              return delegate.getErrorListener();
          }
  
          @Override
          public boolean getFeature(final String name) {
              return delegate.getFeature(name);
          }
  
          @Override
          public URIResolver getURIResolver() {
              return delegate.getURIResolver();
          }
  
          @Override
          public Templates newTemplates(final Source source) {
              return null;
          }
  
          @Override
          public TemplatesHandler newTemplatesHandler() {
              return null;
          }
 
         @Override
         public Transformer newTransformer() {
             return null;
         }
 
         @Override
         public Transformer newTransformer(final Source source) {
             return null;
         }
 
         @Override
         public TransformerHandler newTransformerHandler() {
             return null;
         }
 
         @Override
         public TransformerHandler newTransformerHandler(final Source source) {
             return null;
         }
 
         @Override
         public TransformerHandler newTransformerHandler(final Templates templates) {
             return null;
         }
 
         @Override
         public XMLFilter newXMLFilter(final Source source) {
             return null;
         }
 
         @Override
         public XMLFilter newXMLFilter(final Templates templates) {
             return null;
         }
 
         @Override
         public void setAttribute(final String name, final Object value) {
             attributes.put(name, value);
         }
 
         @Override
         public void setErrorListener(final ErrorListener listener) {
             delegate.setErrorListener(listener);
         }
 
         @Override
         public void setFeature(final String name, final boolean value) throws TransformerConfigurationException {
             delegate.setFeature(name, value);
         }
 
         @Override
         public void setURIResolver(final URIResolver resolver) {
             delegate.setURIResolver(resolver);
         }
     }
 
     private static final class RejectingFeatureFactory extends NullProductsFactory {
 
         /**
          * Always throws {@link TransformerConfigurationException}.
          *
          * @throws TransformerConfigurationException Thrown on every invocation.
          */
         @Override
         public void setFeature(final String name, final boolean value) throws TransformerConfigurationException {
             throw new TransformerConfigurationException(name);
         }
     }
 
     private static void associatedStylesheet(final SAXTransformerFactory factory, final Source source) {
         try {
             factory.getAssociatedStylesheet(source, null, null, null);
         } catch (final TransformerConfigurationException | NullPointerException expected) {
             // Saxon signals no matching PI with TransformerConfigurationException; Xalan rejects a source without an InputSource.
         }
     }
 
     private static StreamSource stylesheet() {
         return new StreamSource(new StringReader(
                 "<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>" + "<xsl:template match='/'/></xsl:stylesheet>"));
     }
 
     @Test
     void preservesNullResultsFromEveryWrappableProduct() throws Exception {
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.secure(new NullProductsFactory());
         final Templates templates = TransformerFactory.newInstance().newTemplates(stylesheet());
         assertNull(factory.newTemplates(stylesheet()));
         assertNull(factory.newTemplatesHandler());
         assertNull(factory.newTransformer());
         assertNull(factory.newTransformer(stylesheet()));
         assertNull(factory.newTransformerHandler());
         assertNull(factory.newTransformerHandler(stylesheet()));
         assertNull(factory.newTransformerHandler(templates));
         // A filter has no null to hand back: a null in this contract would mean the factory has no filters at all.
         assertThrows(TransformerConfigurationException.class, () -> factory.newXMLFilter(stylesheet()));
         factory.setAttribute("test", "value");
         assertEquals("value", factory.getAttribute("test"));
         factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
     }
 
     @Test
     void rejectsDelegatesThatCannotEnableSecureProcessing() {
         assertThrows(SecureException.class, () -> SecureTransformerFactory.secure(new RejectingFeatureFactory()));
     }
 
     @Test
     void rejectsForeignTemplatesFromNewTransformerHandler() throws Exception {
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.newInstance();
         final Templates own = factory.newTemplates(stylesheet());
         // A caller's own Templates wrapper, the shape a framework uses to carry parameters onto the Transformer it hands out.
         final Templates foreign = new Templates() {
 
             @Override
             public Properties getOutputProperties() {
                 return own.getOutputProperties();
             }
 
             @Override
             public Transformer newTransformer() throws TransformerConfigurationException {
                 return own.newTransformer();
             }
         };
         // Xalan and XSLTC reject a Templates they did not compile with an undeclared ClassCastException, where Saxon uses the TrAX shape.
         final TransformerConfigurationException exception = assertThrows(TransformerConfigurationException.class,
                 () -> factory.newTransformerHandler(foreign));
         // Saxon reports it in its own words; where the ClassCastException escaped instead, it must arrive as the cause, under a message naming the Templates.
         if (exception.getCause() instanceof ClassCastException) {
             assertTrue(exception.getMessage().contains(foreign.getClass().getName()), exception.getMessage());
         }
     }
 
     @Test
     void rejectsNullInputOnEveryFactoryMethod() {
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.newInstance();
         assertThrows(NullPointerException.class, () -> factory.newTemplates(null));
         assertThrows(NullPointerException.class, () -> factory.newTransformer(null));
         assertThrows(NullPointerException.class, () -> factory.newTransformerHandler((Source) null));
         assertThrows(NullPointerException.class, () -> factory.newTransformerHandler((Templates) null));
         assertThrows(NullPointerException.class, () -> factory.newXMLFilter((Source) null));
         assertThrows(NullPointerException.class, () -> factory.newXMLFilter((Templates) null));
     }
 
     @Test
     void rejectsTemplatesThatProduceNoTransformer() {
         final Templates templates = new Templates() {
 
             @Override
             public Properties getOutputProperties() {
                 return new Properties();
             }
 
             @Override
             public Transformer newTransformer() {
                 // Xalan hands back null instead of throwing when the stylesheet failed to compile: XALANJ-2410.
                 return null;
             }
         };
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.newInstance();
         // A filter has no null to hand back, so the null the wrappers preserve from Templates is reported in the TrAX shape instead.
         assertThrows(TransformerConfigurationException.class, () -> factory.newXMLFilter(templates));
     }
 
     @Test
     void securesAssociatedStylesheetSourcesOfEverySupportedShape() throws Exception {
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.newInstance();
         associatedStylesheet(factory, new StreamSource(new StringReader("<root/>")));
         associatedStylesheet(factory, new StreamSource(new StringReader("<root>")));
         associatedStylesheet(factory, new SAXSource(new InputSource(new StringReader("<root/>"))));
         associatedStylesheet(factory, new SAXSource());
         associatedStylesheet(factory,
                 new SAXSource(SecureSAXParserFactory.newXMLReader(false), new InputSource(new StringReader("<root/>"))));
         associatedStylesheet(factory,
                 new DOMSource(DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()));
     }
 
     @Test
     void wrapsClassCastExceptionFromNewTransformerHandler() throws Exception {
         final ClassCastException cause = new ClassCastException("Unsupported Templates implementation");
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.secure(new NullProductsFactory() {
 
             /**
              * Always throws {@link ClassCastException}.
              *
              * @throws ClassCastException Thrown on every invocation.
              */
             @Override
             public TransformerHandler newTransformerHandler(final Templates templates) {
                 throw cause;
             }
         });
         final Templates templates = TransformerFactory.newInstance().newTemplates(stylesheet());
         final TransformerConfigurationException exception = assertThrows(TransformerConfigurationException.class,
                 () -> factory.newTransformerHandler(templates));
         assertSame(cause, exception.getCause());
         assertTrue(exception.getMessage().contains(templates.getClass().getName()), exception.getMessage());
     }
 
     @Test
     void wrapsEveryStandardAndSaxFactoryProduct() throws Exception {
         final SAXTransformerFactory factory = (SAXTransformerFactory) SecureTransformerFactory.newInstance();
         final URIResolver resolver = (href, base) -> null;
         factory.setURIResolver(resolver);
         assertSame(resolver, factory.getURIResolver());
         factory.setErrorListener(factory.getErrorListener());
         try {
             factory.setAttribute("indent-number", 2);
             // XSLTC quirk: the attribute is settable but not readable.
             assertThrows(IllegalArgumentException.class, () -> factory.getAttribute("indent-number"));
         } catch (final IllegalArgumentException e) {
             // Saxon and Xalan reject the XSLTC-only attribute at set time; the delegate's rejection is itself the forwarding proof.
         }
         final Templates templates = factory.newTemplates(stylesheet());
         assertInstanceOf(SecureTemplates.class, templates);
         assertInstanceOf(SecureTransformer.class, factory.newTransformer());
         assertInstanceOf(SecureTransformer.class, factory.newTransformer(stylesheet()));
         assertInstanceOf(SecureTemplatesHandler.class, factory.newTemplatesHandler());
         assertInstanceOf(SecureTransformerHandler.class, factory.newTransformerHandler());
         assertInstanceOf(SecureTransformerHandler.class, factory.newTransformerHandler(stylesheet()));
         assertInstanceOf(SecureTransformerHandler.class, factory.newTransformerHandler(templates));
         assertInstanceOf(SecureXMLFilter.class, factory.newXMLFilter(stylesheet()));
         assertInstanceOf(SecureXMLFilter.class, factory.newXMLFilter(templates));
         final Templates rawTemplates = TransformerFactory.newInstance().newTemplates(stylesheet());
         assertInstanceOf(SecureXMLFilter.class, factory.newXMLFilter(rawTemplates));
         associatedStylesheet(factory, new StreamSource(new StringReader("<root/>")));
         assertInstanceOf(SecureTransformer.class, SecureTransformerFactory.newInstance().newTransformer());
     }
 }