AbstractXMLDiff.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */


  22. package org.openspcoop2.utils.xml;

  24. import java.io.ByteArrayInputStream;
  25. import java.io.File;
  26. import java.io.FileInputStream;
  27. import java.io.InputStream;
  28. import java.io.Reader;
  29. import java.util.List;

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

  34. import org.apache.commons.io.input.ReaderInputStream;
  35. import org.slf4j.Logger;
  36. import org.custommonkey.xmlunit.DetailedDiff;
  37. import org.custommonkey.xmlunit.Difference;
  38. import org.custommonkey.xmlunit.XMLUnit;
  39. import org.openspcoop2.utils.LoggerWrapperFactory;
  40. import org.w3c.dom.Document;
  41. import org.w3c.dom.Element;
  42. import org.w3c.dom.Node;
  43. import org.xml.sax.InputSource;

  45. /**
  46.  * Classe utilizzabile per ricerche effettuate tramite espressioni XQuery
  47.  *
  48.  * @author Andrea Poli (apoli@link.it)
  49.  * @author $Author$
  50.  * @version $Rev$, $Date$
  51.  */

  53. public abstract class AbstractXMLDiff {

  55.     
  56.     @SuppressWarnings("unused")
  57.     private static Logger logger = LoggerWrapperFactory.getLogger(AbstractXMLDiff.class);
  58.     public static void setLogger(Logger logger) {
  59.         AbstractXMLDiff.logger = logger;
  60.     }
  61.     
  62.     // Static options, la libreria XMLUnit permette di definire queste proprietà staticamente.
  63.     private static XMLDiffOptions xmlDiffOptions = new XMLDiffOptions();
  64.     private static XMLDiffImplType implType = XMLDiffImplType.XML_UNIT;
  65.     private static DocumentBuilderFactory dbf_org_w3c_dom_document_impl = null;
  66.     public static XMLDiffImplType getImplType() {
  67.         return AbstractXMLDiff.implType;
  68.     }
  69.     public static void setImplType(XMLDiffImplType implType) {
  70.         AbstractXMLDiff.implType = implType;
  71.     }
  72.     public static XMLDiffOptions getXmlDiffOptions() {
  73.         return AbstractXMLDiff.xmlDiffOptions;
  74.     }
  75.     public static void setXmlDiffOptions(XMLDiffOptions xmlDiffOptions) {
  76.         AbstractXMLDiff.xmlDiffOptions = xmlDiffOptions;
  77.     }
  78.     private static boolean initialized = false;
  79.     private static synchronized void initialize(AbstractXMLUtils instance) throws XMLException{
  80.         if(AbstractXMLDiff.initialized==false){
  81.             
  82.             AbstractXMLDiff.dbf_org_w3c_dom_document_impl = instance.newDocumentBuilderFactory();
  83.             AbstractXMLDiff.dbf_org_w3c_dom_document_impl.setNamespaceAware(true);
  84.             AbstractXMLDiff.dbf_org_w3c_dom_document_impl.setCoalescing(AbstractXMLDiff.xmlDiffOptions.isIgnoreDiffBetweenTextAndCDATA());
  85.             AbstractXMLDiff.dbf_org_w3c_dom_document_impl.setIgnoringElementContentWhitespace(AbstractXMLDiff.xmlDiffOptions.isIgnoreWhitespace());
  86.             AbstractXMLDiff.dbf_org_w3c_dom_document_impl.setIgnoringComments(AbstractXMLDiff.xmlDiffOptions.isIgnoreComments());
  87.             
  88.             if(XMLDiffImplType.XML_UNIT.equals(AbstractXMLDiff.implType)){
  89.                 XMLUnit.setIgnoreAttributeOrder(true);
  90.                 XMLUnit.setExpandEntityReferences(true);
  91.                 XMLUnit.setIgnoreComments(AbstractXMLDiff.xmlDiffOptions.isIgnoreComments());
  92.                 XMLUnit.setIgnoreDiffBetweenTextAndCDATA(AbstractXMLDiff.xmlDiffOptions.isIgnoreDiffBetweenTextAndCDATA());
  93.                 XMLUnit.setIgnoreWhitespace(AbstractXMLDiff.xmlDiffOptions.isIgnoreWhitespace());
  94.                 XMLUnit.setNormalize(AbstractXMLDiff.xmlDiffOptions.isNormalize());
  95.                 XMLUnit.setNormalizeWhitespace(AbstractXMLDiff.xmlDiffOptions.isNormalize());
  96.             }
  97.             
  98.             AbstractXMLDiff.initialized = true;
  99.         }
  100.     }
  101.     private static synchronized void _initialize(XMLDiffImplType implType,XMLDiffOptions xmlDiffOptions,AbstractXMLUtils instance) throws XMLException{
  102.         AbstractXMLDiff.implType = implType;
  103.         AbstractXMLDiff.xmlDiffOptions = xmlDiffOptions;
  104.         AbstractXMLDiff.initialize(instance);
  105.     }

  107.     
  108.     /* ***** INIT METHOD (ha bisogno degli abstract method) ***** */
  109.     
  110.     public void initialize(XMLDiffImplType implType,XMLDiffOptions xmlDiffOptions) throws XMLException{
  111.         AbstractXMLDiff._initialize(implType,xmlDiffOptions,this.getXMLUtils());
  112.     }
  113.     
  114.     
  115.     /* ***** ABSTRACT METHOD ***** */
  116.     
  117.     public abstract AbstractXMLUtils getXMLUtils();
  118.     public abstract Element readXPathElement(Element contenutoAsElement);
  119.     public abstract void normalizeDocument(Document document);

  121.     
  122.     /* ***** EXCEPTION METHOD ***** */

  124.     private String difference;
  125.     
  126.     public String getDifferenceDetails() throws XMLException {
  127.         if(!XMLDiffImplType.XML_UNIT.equals(AbstractXMLDiff.implType)){
  128.             throw new XMLException("Difference details permit only on implementation: "+XMLDiffImplType.XML_UNIT);
  129.         }
  130.         return this.difference;
  131.     }

  133.     
  134.     
  135.     
  136.         
  137.     
  138.     /* ***** ENGINE ***** */
  139.     
  140.     private boolean _diff(Object original, Object compare) throws XMLException{
  141.         
  142.         if(AbstractXMLDiff.initialized==false){
  143.             throw new XMLException("Library not initialized. Invoke initialize method");
  144.         }
  145.         
  146.         if(XMLDiffImplType.XML_UNIT.equals(AbstractXMLDiff.implType)){
  147.             return this._diffXmlUnit(original, compare);
  148.         }
  149.         else if(XMLDiffImplType.ORG_W3C_DOM_DOCUMENT.equals(AbstractXMLDiff.implType)){
  150.             return this._diffW3cDomDocument(original, compare);
  151.         }
  152.         else{
  153.             throw new XMLException("Implementation ["+AbstractXMLDiff.implType+"] not supported");
  154.         }

  156.     }
  157.     
  158.     private boolean _diffXmlUnit(Object original, Object compare) throws XMLException{
  159.         
  160.         DetailedDiff diff = null;
  161.         
  162.         if( (original instanceof Document) || (original instanceof Element) || (original instanceof Node) ){
  163.             // Ottengo anche il compare come Document e li confronto
  164.             Document docOriginal = this._getDiffW3cDomDocument(original, "original");
  165.             Document docCompare = this._getDiffW3cDomDocument(compare, "compare");
  166.             if(AbstractXMLDiff.xmlDiffOptions.isNormalize()){
  167.                 normalizeDocument(docOriginal);
  168.                 normalizeDocument(docCompare);
  169.             }
  170.             diff = new DetailedDiff(XMLUnit.compareXML(docOriginal,docCompare));
  171.         }
  172.         else if( (original instanceof Reader) && (compare instanceof Reader) ){
  173.             Reader rOriginal = (Reader) original;
  174.             Reader rCompare = (Reader) compare;
  175.             try{
  176.                 diff = new DetailedDiff(XMLUnit.compareXML(rOriginal,rCompare));
  177.             }catch(Exception e){
  178.                 throw new XMLException(e.getMessage(),e);
  179.             }
  180.         }
  181.         else if( (original instanceof Reader) && (compare instanceof String) ){
  182.             Reader rOriginal = (Reader) original;
  183.             String sCompare = (String) compare;
  184.             try{
  185.                 diff = new DetailedDiff(XMLUnit.compareXML(rOriginal,sCompare));
  186.             }catch(Exception e){
  187.                 throw new XMLException(e.getMessage(),e);
  188.             }
  189.         }
  190.         else if( (original instanceof String) && (compare instanceof Reader) ){
  191.             String sOriginal = (String) original;
  192.             Reader rCompare = (Reader) compare;
  193.             try{
  194.                 diff = new DetailedDiff(XMLUnit.compareXML(sOriginal,rCompare));
  195.             }catch(Exception e){
  196.                 throw new XMLException(e.getMessage(),e);
  197.             }
  198.         }
  199.         else if( (original instanceof String) && (compare instanceof String) ){
  200.             String sOriginal = (String) original;
  201.             String sCompare = (String) compare;
  202.             try{
  203.                 diff = new DetailedDiff(XMLUnit.compareXML(sOriginal,sCompare));
  204.             }catch(Exception e){
  205.                 throw new XMLException(e.getMessage(),e);
  206.             }
  207.         }
  208.         else if( 
  209.                 ( (original instanceof InputStream) || (original instanceof File) ) 
  210.                 && 
  211.                 ( (compare instanceof InputStream) || (compare instanceof File) ) 
  212.                 ){
  213.             InputSource isOriginal = null;
  214.             InputSource isCompare = null;
  215.             FileInputStream finOriginal = null;
  216.             FileInputStream finCompare = null;
  217.             try{
  218.                 
  219.                 if(original instanceof InputStream){
  220.                     isOriginal = new InputSource((InputStream)original);
  221.                 }
  222.                 else if(original instanceof File){
  223.                     finOriginal = new FileInputStream((File)original);
  224.                     isOriginal = new InputSource(finOriginal);
  225.                 }
  226.                 
  227.                 if(compare instanceof InputStream){
  228.                     isCompare = new InputSource((InputStream)compare);
  229.                 }
  230.                 else if(compare instanceof File){
  231.                     finCompare = new FileInputStream((File)compare);
  232.                     isCompare = new InputSource(finCompare);
  233.                 }
  234.                 
  235.                 diff = new DetailedDiff(XMLUnit.compareXML(isOriginal,isCompare));
  236.                 
  237.             }catch(Exception e){
  238.                 throw new XMLException(e.getMessage(),e);
  239.             }finally{
  240.                 try{
  241.                     if(finOriginal!=null){
  242.                         finOriginal.close();
  243.                     }
  244.                 }catch(Exception eClose){}
  245.                 try{
  246.                     if(finCompare!=null){
  247.                         finCompare.close();
  248.                     }
  249.                 }catch(Exception eClose){
  250.                     // close
  251.                 }
  252.             }
  253.         }
  254.         else{
  255.             // Ottengo anche il compare come Document e li confronto
  256.             Document docOriginal = this._getDiffW3cDomDocument(original, "original");
  257.             Document docCompare = this._getDiffW3cDomDocument(compare, "compare");
  258.             if(AbstractXMLDiff.xmlDiffOptions.isNormalize()){
  259.                 normalizeDocument(docOriginal);
  260.                 normalizeDocument(docCompare);
  261.             }
  262.             diff = new DetailedDiff(XMLUnit.compareXML(docOriginal,docCompare));
  263.         }
  264.         
  265.         
  266.         if(diff!=null && diff.identical()==false){
  267.             StringBuilder bfDifferences = new StringBuilder();
  268.             List<?> allDifferences = diff.getAllDifferences();
  269.             bfDifferences.append("allDifferences: "+ allDifferences.size());
  270.             bfDifferences.append("\n");
  271.             int index = 1;
  272.             for (Object object : allDifferences) {
  273.                  if(object instanceof Difference){
  274.                      Difference d = (Difference) object;
  275.                      bfDifferences.append("Diff-"+index+": "+d.toString());
  276.                      bfDifferences.append("\n");
  277.                  }
  278.                  index++;
  279.             }          
  280.             this.difference = bfDifferences.toString();
  281.         }
  282.         return diff!=null ? diff.identical() : false;
  283.         
  284.     }
  285.     
  286.     private boolean _diffW3cDomDocument(Object original, Object compare) throws XMLException{
  287.         
  288.         Document docOriginal = this._getDiffW3cDomDocument(original, "original");
  289.         Document docCompare = this._getDiffW3cDomDocument(compare, "compare");
  290.         if(AbstractXMLDiff.xmlDiffOptions.isNormalize()){
  291.             normalizeDocument(docOriginal);
  292.             normalizeDocument(docCompare);
  293.         }
  294.         return docOriginal.isEqualNode(docCompare);
  295.     }
  296.     
  297.     private Document _getDiffW3cDomDocument(Object o,String parameterName) throws XMLException{
  298.         
  299.         if(o==null){
  300.             throw new XMLException("Object is null for parameter ["+parameterName+"]");
  301.         }
  302.         
  303.         if(o instanceof Document){
  304.             return (Document) o;
  305.         }
  306.         else if(o instanceof Element){
  307.             return ((Element) o).getOwnerDocument();
  308.         }
  309.         else if(o instanceof Node){
  310.             return ((Node) o).getOwnerDocument();
  311.         }
  312.         else if( 
  313.                 (o instanceof String) ||
  314.                 (o instanceof File) ||
  315.                 (o instanceof InputStream) ||
  316.                 (o instanceof Reader)
  317.                 ){
  318.             ReaderInputStream ris = null;
  319.             try{
  320.                 DocumentBuilder db = AbstractXMLDiff.dbf_org_w3c_dom_document_impl.newDocumentBuilder();
  321.                 if(o instanceof String){
  322.                     byte [] b = ((String)o).getBytes();
  323.                     return db.parse(new ByteArrayInputStream(b));
  324.                 }
  325.                 else if(o instanceof File){
  326.                     return db.parse((File)o);
  327.                 }
  328.                 else if(o instanceof InputStream){
  329.                     return db.parse((InputStream)o);
  330.                 }
  331.                 else if(o instanceof Reader){
  332.                     Reader r = (Reader) o;
  333.                     ris = ReaderInputStream.builder()
  334.                             .setReader(r)
  335.                             .setCharset(org.openspcoop2.utils.resources.Charset.UTF_8.getValue())
  336.                             .get();
  337.                     return db.parse( ris );
  338.                 }
  339.                 else{
  340.                     throw new XMLException("Object type ["+o.getClass().getName()+"] not supported ?? for parameter ["+parameterName+"]");
  341.                 }
  342.             }catch(Exception e){
  343.                 throw new XMLException("Object type ["+o.getClass().getName()+"] parser error for parameter ["+parameterName+"]: "+e.getMessage(),e);
  344.             }finally{
  345.                 try{
  346.                     if(ris!=null){
  347.                         ris.close();
  348.                     }
  349.                 }catch(Exception eClose){
  350.                     // close
  351.                 }
  352.             }
  353.         }
  354.         else{
  355.             throw new XMLException("Object type ["+o.getClass().getName()+"] not supported for parameter ["+parameterName+"]");
  356.         }
  357.     }

  359.     
  360.     
  361.     /* ***** PUBLIC METHOD (SRC as Node) ***** */
  362.     
  363.     public boolean diff(String original, String compare)throws XMLException{
  364.         return this._diff(original, compare);
  365.     }
  366.     public boolean diff(File original, File compare)throws XMLException{
  367.         return this._diff(original, compare);
  368.     }
  369.     public boolean diff(InputStream original, InputStream compare)throws XMLException{
  370.         return this._diff(original, compare);
  371.     }
  372.     public boolean diff(Reader original, Reader compare)throws XMLException{
  373.         return this._diff(original, compare);
  374.     }
  375.     public boolean diff(Document original, Document compare)throws XMLException{
  376.         return this._diff(original, compare);
  377.     }
  378.     public boolean diff(Element original, Element compare)throws XMLException{
  379.         return this._diff(original, compare);
  380.     }
  381.     public boolean diff(Node original, Node compare)throws XMLException{
  382.         return this._diff(original, compare);
  383.     }
  384.     public boolean diff(Object original, Object compare)throws XMLException{
  385.         return this._diff(original, compare);
  386.     }


  389. }
Created with JaCoCo 0.8.8.202204050719