如何对比两个文件夹内的同名XML文件差异？多文件测试技术方案问询

Absolutely! Comparing identically named XML files across two folders and spotting their differences is a common testing requirement, and there are reliable, actionable solutions in Python, Java, and Groovy. Let’s walk through the core approach first, then dive into concrete code examples for each language.

Core Approach #

No matter which language you pick, the workflow follows these key steps:

• Traverse both target folders to identify pairs of XML files that share the same name
• Parse each XML file into a structured format (like a DOM tree, dictionary, or element object)
• Compare the structured content to detect differences (node values, attributes, missing/extra nodes, etc.)
• Generate clear, actionable output that lists which file pairs have differences and what those differences are

Python Solution #

Python is ideal for quick scripting here, thanks to its easy file handling and great libraries for XML parsing and deep comparison. We’ll use xml.etree.ElementTree for XML parsing and deepdiff to spot differences in nested structures.

Step 1: Install Dependencies #

First, install the deepdiff library if you don’t have it:

pip install deepdiff

Step 2: Full Script Example #

import os
import xml.etree.ElementTree as ET
from deepdiff import DeepDiff

def xml_to_dict(element):
    """Convert an XML Element to a dictionary for easy comparison"""
    result = {}
    # Add attributes
    if element.attrib:
        result["@attributes"] = element.attrib
    # Add child elements
    children = list(element)
    if children:
        child_dict = {}
        for child in children:
            child_key = child.tag
            child_val = xml_to_dict(child)
            if child_key in child_dict:
                # Handle multiple children with the same tag
                if not isinstance(child_dict[child_key], list):
                    child_dict[child_key] = [child_dict[child_key]]
                child_dict[child_key].append(child_val)
            else:
                child_dict[child_key] = child_val
        result.update(child_dict)
    # Add text content if present (and not just whitespace)
    if element.text and element.text.strip():
        result["#text"] = element.text.strip()
    return result

def compare_xml_folders(folder1, folder2):
    # Get all XML files in folder1
    xml_files1 = {f for f in os.listdir(folder1) if f.lower().endswith(".xml")}
    # Get all XML files in folder2
    xml_files2 = {f for f in os.listdir(folder2) if f.lower().endswith(".xml")}
    # Find common files
    common_files = xml_files1.intersection(xml_files2)

    for filename in common_files:
        path1 = os.path.join(folder1, filename)
        path2 = os.path.join(folder2, filename)

        try:
            # Parse XML files
            tree1 = ET.parse(path1)
            root1 = tree1.getroot()
            tree2 = ET.parse(path2)
            root2 = tree2.getroot()

            # Convert to dictionaries
            dict1 = xml_to_dict(root1)
            dict2 = xml_to_dict(root2)

            # Compare
            diff = DeepDiff(dict1, dict2, ignore_order=True)
            if diff:
                print(f"=== Differences found in {filename} ===")
                print(diff)
                print("\n")
            else:
                print(f"No differences found in {filename}\n")
        except ET.ParseError as e:
            print(f"Error parsing {filename}: {str(e)}")
        except Exception as e:
            print(f"Unexpected error processing {filename}: {str(e)}")

# Usage
if __name__ == "__main__":
    FOLDER_A = "/path/to/folder1"
    FOLDER_B = "/path/to/folder2"
    compare_xml_folders(FOLDER_A, FOLDER_B)

Notes #

• The xml_to_dict function converts XML elements to dictionaries, making it easy to use deepdiff for comparison.
• ignore_order=True in DeepDiff ensures that child nodes in different order don’t count as differences (adjust this if node order matters for your test).
• The script handles basic edge cases like parsing errors and missing files.

Java Solution #

For Java-based testing workflows, XMLUnit is the go-to library—it’s designed specifically for XML comparison and lets you configure exactly what counts as a difference (whitespace, comments, node order, etc.).

Step 1: Add XMLUnit Dependency #

If using Maven, add this to your pom.xml:

<dependency>
    <groupId>org.xmlunit</groupId>
    <artifactId>xmlunit-core</artifactId>
    <version>2.9.1</version>
</dependency>
<dependency>
    <groupId>org.xmlunit</groupId>
    <artifactId>xmlunit-matchers</artifactId>
    <version>2.9.1</version>
</dependency>

Step 2: Full Code Example #

import org.xmlunit.builder.DiffBuilder;
import org.xmlunit.diff.Diff;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class XmlFolderComparator {

    public static void main(String[] args) {
        String folder1Path = "/path/to/folder1";
        String folder2Path = "/path/to/folder2";

        try {
            Map<String, Path> folder1Files = getXmlFiles(folder1Path);
            Map<String, Path> folder2Files = getXmlFiles(folder2Path);

            // Iterate over common files
            for (String filename : folder1Files.keySet()) {
                if (folder2Files.containsKey(filename)) {
                    Path file1 = folder1Files.get(filename);
                    Path file2 = folder2Files.get(filename);
                    compareXmlFiles(file1, file2);
                } else {
                    System.out.println(filename + " exists in folder1 but not in folder2\n");
                }
            }

            // Check for files in folder2 not present in folder1
            for (String filename : folder2Files.keySet()) {
                if (!folder1Files.containsKey(filename)) {
                    System.out.println(filename + " exists in folder2 but not in folder1\n");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static Map<String, Path> getXmlFiles(String folderPath) throws IOException {
        Map<String, Path> xmlFiles = new HashMap<>();
        Files.walk(Paths.get(folderPath))
                .filter(Files::isRegularFile)
                .filter(path -> path.getFileName().toString().toLowerCase().endsWith(".xml"))
                .forEach(path -> xmlFiles.put(path.getFileName().toString(), path));
        return xmlFiles;
    }

    private static void compareXmlFiles(Path file1, Path file2) {
        String filename = file1.getFileName().toString();
        Diff diff = DiffBuilder.compare(file1.toFile())
                .withTest(file2.toFile())
                .ignoreWhitespace() // Ignore irrelevant whitespace
                .ignoreComments()   // Ignore XML comments
                .checkForSimilar()  // Treats nodes in different order as similar (not different)
                .build();

        if (diff.hasDifferences()) {
            System.out.println("=== Differences found in " + filename + " ===");
            diff.getDifferences().forEach(d -> System.out.println(d.toString()));
            System.out.println("\n");
        } else {
            System.out.println("No differences found in " + filename + "\n");
        }
    }
}

Notes #

• XMLUnit’s DiffBuilder lets you fine-tune comparison rules—adjust ignoreWhitespace, ignoreComments, or checkForSimilar based on your test requirements.
• The code uses Java NIO for efficient folder traversal and handles cases where files are missing from one folder.

Groovy Solution #

Groovy’s concise syntax and built-in XML support make this task even simpler. We’ll use Groovy’s XmlSlurper for parsing and still leverage XMLUnit for robust comparison (since it’s compatible with Java libraries).

Step 1: Add XMLUnit Dependency #

If using Gradle, add this to your build.gradle:

dependencies {
    implementation 'org.xmlunit:xmlunit-core:2.9.1'
    implementation 'org.xmlunit:xmlunit-matchers:2.9.1'
}

Step 2: Full Script Example #

import org.xmlunit.builder.DiffBuilder

def compareXmlFolders(String folder1, String folder2) {
    // Get XML files in each folder
    def folder1Files = new File(folder1).listFiles().findAll { it.name.toLowerCase().endsWith('.xml') }
            .collectEntries { [it.name, it] }
    def folder2Files = new File(folder2).listFiles().findAll { it.name.toLowerCase().endsWith('.xml') }
            .collectEntries { [it.name, it] }

    // Compare common files
    folder1Files.each { filename, file1 ->
        def file2 = folder2Files[filename]
        if (file2) {
            def diff = DiffBuilder.compare(file1)
                    .withTest(file2)
                    .ignoreWhitespace()
                    .ignoreComments()
                    .checkForSimilar()
                    .build()

            if (diff.hasDifferences()) {
                println "=== Differences found in $filename ==="
                diff.differences.each { println it }
                println "\n"
            } else {
                println "No differences found in $filename\n"
            }
        } else {
            println "$filename exists in folder1 but not in folder2\n"
        }
    }

    // Check for files only in folder2
    folder2Files.each { filename, file2 ->
        if (!folder1Files.containsKey(filename)) {
            println "$filename exists in folder2 but not in folder1\n"
        }
    }
}

// Usage
def FOLDER_A = "/path/to/folder1"
def FOLDER_B = "/path/to/folder2"
compareXmlFolders(FOLDER_A, FOLDER_B)

Notes #

• Groovy’s collectEntries and each closures simplify folder traversal and file matching.
• XmlSlurper is great for quick XML inspection if you need to extract specific nodes before comparison, but XMLUnit handles full-document comparison seamlessly.

All these solutions can be adapted to your specific testing needs—for example, you could write differences to a report file instead of the console, or add more granular checks for specific XML nodes.

内容的提问来源于stack exchange，提问作者Manideep Jujjuru