The XML catalog unit test that verifies if the local XSD files matches the content of the XML catalog is ready.

Signed-off-by: Nicolas-Peiffer <[email protected]>

Author: Nicolas-Peiffer

tools/pom.xml

@@ -145,5 +145,10 @@
                 <version>3.2.5</version>
             </plugin>
         </plugins>
+        <testResources>
+            <testResource>
+                <directory>${basedir}/../schema</directory>
+            </testResource>
+        </testResources>
     </build>
 </project>

tools/src/test/java/org/cyclonedx/schema/XmlCatalogVerificationTest.java

@@ -10,44 +10,50 @@
 import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
+import javax.xml.namespace.NamespaceContext;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
 
-import java.io.InputStream;
 import java.io.IOException;
-import java.io.StringReader;
-import java.nio.charset.StandardCharsets;
+import java.io.InputStream;
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.DynamicTest.dynamicTest;
 
 public class XmlCatalogVerificationTest {
 
     /**
-     * Tests the XML catalog by parsing the xmlcatalog.xml file and checking if the namespaces
-     * in the XSD schema files match the namespaces defined in the xmlcatalog.xml file.
+     * Tests the XML catalog by parsing the xmlcatalog.xml file and verifying if the XML namespaces
+     * in the referenced XSD schema files match the XML namespaces defined in the xmlcatalog.xml file.
      *
      * @return  a list of dynamic tests for each URI in the xmlcatalog.xml file
      * @throws IOException                  if an I/O error occurs while reading the XML catalog file
      * @throws ParserConfigurationException if a parser configuration error occurs
      * @throws SAXException                 if a SAX error occurs while parsing the XML catalog file
+     * @throws XPathExpressionException     if an XPath expression error occurs
      */
     @TestFactory
-    public List<DynamicTest> testXmlCatalog() throws IOException, ParserConfigurationException, SAXException {
-        // Define the path to the XML catalog file
+    public List<DynamicTest> testXmlCatalog() throws IOException, ParserConfigurationException, SAXException, XPathExpressionException {
+        // Define the path to the XML catalog file. This is relative to "${basedir}/../schema" in the pom.xml.
         String xmlCatalogFilename = "xmlcatalog.xml";
 
         // Load the XML catalog file from the classpath
         ClassLoader classLoader = getClass().getClassLoader();
         InputStream xmlCatalogStream = classLoader.getResourceAsStream(xmlCatalogFilename);
 
+        // Ensure the XML catalog file is found
         Assertions.assertNotNull(xmlCatalogStream, "XML catalog file not found");
 
         // Parse the xmlcatalog.xml file
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setNamespaceAware(true);  // Make the factory namespace-aware
         DocumentBuilder builder = factory.newDocumentBuilder();
         Document xmlCatalogDocument = builder.parse(new InputSource(xmlCatalogStream));
 
@@ -60,39 +66,64 @@ public List<DynamicTest> testXmlCatalog() throws IOException, ParserConfiguratio
         // Iterate through the XML catalog elements
         for (int i = 0; i < xmlCatalogElements.getLength(); i++) {
             Node xmlCatalogElement = xmlCatalogElements.item(i);
+
+            // Check if the element is a <uri> element
             if (xmlCatalogElement.getNodeName().equals("uri")) {
-                String uriName = xmlCatalogElement.getAttributes().getNamedItem("name").getTextContent();
+                // Get the URI name and the local filename of the XSD schema
+                String uriNameXmlCtlg = xmlCatalogElement.getAttributes().getNamedItem("name").getTextContent();
                 String xsdLocalFilename = xmlCatalogElement.getAttributes().getNamedItem("uri").getTextContent();
 
-                // Create a dynamic test for each URI
-                dynamicTests.add(dynamicTest("Testing URI: " + uriName, () -> {
-                    // Load the XSD schema file from the classpath
-                    InputStream xsdSchemaFileStream = classLoader.getResourceAsStream(xsdLocalFilename);
-                    Assertions.assertNotNull(xsdSchemaFileStream, "The following file is missing: " + xsdLocalFilename);
-
-                    // Read the XSD local file content
-                    String xsdContent = new String(xsdSchemaFileStream.readAllBytes(), StandardCharsets.UTF_8);
-
-                    // Parse the XSD file content to a Document object
-                    Document xsdDocument = builder.parse(new InputSource(new StringReader(xsdContent)));
-
-                    // Check if the XSD document contains the expected namespace
-                    NodeList schemaNodes = xsdDocument.getElementsByTagNameNS("*", "schema");
-                    boolean namespaceFound = false;
-                    for (int j = 0; j < schemaNodes.getLength(); j++) {
-                        Node schemaNode = schemaNodes.item(j);
-                        String targetNamespace = schemaNode.getAttributes().getNamedItem("targetNamespace").getTextContent();
-                        System.out.println("uriName.equals(targetNamespace)" + uriName.equals(targetNamespace));
-                        if (uriName.equals(targetNamespace)) {
-                            namespaceFound = true;
-                            break;
+                // Load the XSD schema local file from the classpath
+                InputStream xsdSchemaFileStream = classLoader.getResourceAsStream(xsdLocalFilename);
+                Assertions.assertNotNull(xsdSchemaFileStream, "The following file is missing: " + xsdLocalFilename);
+
+                // Parse the XSD schema local file
+                DocumentBuilderFactory factoryXsd = DocumentBuilderFactory.newInstance();
+                factoryXsd.setNamespaceAware(true);  // Make the factory namespace-aware
+                DocumentBuilder builderXsd = factoryXsd.newDocumentBuilder();
+                Document xsdDocument = builderXsd.parse(new InputSource(xsdSchemaFileStream));
+
+                // Create an XPath instance to evaluate the targetNamespace field found in the XSD schema
+                XPath xPath = XPathFactory.newInstance().newXPath();
+                xPath.setNamespaceContext(new NamespaceContext() {
+                    @Override
+                    public String getNamespaceURI(String prefix) {
+                        // Define the namespace URI for the xs prefix
+                        if ("xs".equals(prefix)) {
+                            return "http://www.w3.org/2001/XMLSchema";
+                        }
+                        return null;
+                    }
+
+                    @Override
+                    public String getPrefix(String namespaceURI) {
+                        // Define the prefix for the namespace URI
+                        if ("http://www.w3.org/2001/XMLSchema".equals(namespaceURI)) {
+                            return "xs";
                         }
+                        return null;
                     }
-                    assertTrue(namespaceFound, "The namespace " + uriName + " is not present in file " + xsdLocalFilename);
+
+                    @Override
+                    public Iterator<String> getPrefixes(String namespaceURI) {
+                        return null;
+                    }
+                });
+
+                // Evaluate the targetNamespace attribute from the XSD document
+                String targetNamespace = (String) xPath.evaluate("/xs:schema/@targetNamespace", xsdDocument, XPathConstants.STRING);
+
+                // Assert if the targetNamespace from the XSD file matches the uriNameXmlCtlg from the XML catalog
+                Assertions.assertEquals(uriNameXmlCtlg, targetNamespace, "The namespace " + uriNameXmlCtlg + " does not match the targetNamespace in file " + xsdLocalFilename);
+
+                // Create a dynamic test for each URI
+                dynamicTests.add(dynamicTest("Testing if URI namespace from the XML catalog: " + uriNameXmlCtlg + " matches the URI namespace from the local XSD file: " + targetNamespace, () -> {
+                    // Dummy test, the namespace check is done before
                 }));
             }
         }
 
+        // Return the list of dynamic tests
         return dynamicTests;
     }
 }