Test d'unité de Génération de données XML

D'abord, comme à peu près tout le monde dit que, valider le XML si il y a un schéma défini pour elle. (Si il n'y a pas, en définir un.)

Mais vous pouvez construire des tests qui sont beaucoup plus précis que celui de l'exécution des requêtes XPath sur le document, par exemple:

string xml="Your xml string here" ;
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
path = "/doc/element1[@id='key1']/element2[. = 'value2']";
Assert.IsTrue(doc.SelectSingleNode(path) != null);

Ceci vous permet de tester non seulement de savoir si ou non votre document est sémantiquement valide, mais si oui ou non la méthode de production est le remplissant avec les valeurs que vous attendez.

Couramment Affirmations est une excellente bibliothèque pour exprimer test affirmations contenues dans un fluide, facile à lire, le style. Il fonctionne avec toutes les grandes infrastructures de Test Unitaire.

Il a aussi quelques fonctionnalités XML (toutes prises à partir de ces exemples ici), par exemple:

xElementA.Should().Be(xElementB);

xDocument.Should().HaveRoot("configuration");
xDocument.Should().HaveElement("settings");

xElement.Should().HaveAttribute("age", "36");
xElement.Should().HaveElement("address");

xAttribute.Should().HaveValue("Amsterdam");

Notez que cela fonctionne avec LINQ-to-XML plutôt que l'objet XmlDocument spécifié dans la question d'origine, mais personnellement ces jours-ci, je trouve que je suis à l'aide de LINQ-to-XML comme un premier choix.

Il est également facilement extensible, si vous souhaitez ajouter d'autres XML assertions pour s'adapter à vos besoins.

Validation XML schéma ou DTD, cochez aussi la clé que les nœuds ont les valeurs que vous attendez.

Ce blog par marianor donne un moyen léger de comparer XElement structures, donc je vais essayer ça avant de s'attaquer à XMLUnit.

La première chose à faire est de normaliser les deux XMLs...à l'aide de Linq... Après que les deux éléments ont été normalisées, tout simplement, vous pouvez comparer deux chaînes.

Le XML est normalisé par trier les noms d'élément et attribut.

Une autre raison d'utiliser un Schéma pour la validation, c'est que tandis que les noeuds qui sont explicitement ordonné, attributs XML ne sont pas.

Donc votre comparaison de chaînes de:

Assert.AreEqual(myDoc.OuterXML(),"big string of XML")

serait un échec si les attributs sont dans un ordre différent, comme pourrait facilement se produire si un peu de XML a été créé manuellement et l'autre par programmation.

J'ai l'intention sur l'utilisation de cette nouvelle Les Essais D'Approbation de la bibliothèque à l'aide de la norme XML de test.

Il semble être parfait pour le travail, mais lisez d'abord vous-même que je n'ai pas d'expérience dans l'utilisation il.

Vous pouvez utiliser une DTD pour vérifier la validité du xml généré.

Pour tester le bon contenu, je voudrais aller XMLUnit.

Affirmant xml à l'aide de XMLUnit:

XMLUnit.setIgnoreWhitespace(true);
XMLUnit.setIgnoreDiffBetweenTextAndCDATA(true);

Diff diff = new Diff(expectedDocument, obtainedDocument);
XMLAssert.assertXMLIdentical("xml invalid", diff, true);

Une chose que vous pourriez rencontrer est le fait que le xml généré peut contenir de changer les identifiants (id/uid attributs ou similaire). Ce problème peut être résolu par l'utilisation d'un DifferenceListener en revendiquant le xml généré.

Exemple de mise en œuvre de ces DifferenceListener:

public class IgnoreVariableAttributesDifferenceListener implements DifferenceListener {

    private final List<String> IGNORE_ATTRS;
    private final boolean ignoreAttributeOrder;

    public IgnoreVariableAttributesDifferenceListener(List<String> attributesToIgnore, boolean ignoreAttributeOrder) {
        this.IGNORE_ATTRS = attributesToIgnore;
        this.ignoreAttributeOrder = ignoreAttributeOrder;
    }

    @Override
    public int differenceFound(Difference difference) {
        //for attribute value differences, check for ignored attributes
        if (difference.getId() == DifferenceConstants.ATTR_VALUE_ID) {
            if (IGNORE_ATTRS.contains(difference.getControlNodeDetail().getNode().getNodeName())) {
                return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
            }
        }
        //attribute order mismatch (optionally ignored)
        else if (difference.getId() == DifferenceConstants.ATTR_SEQUENCE_ID && ignoreAttributeOrder) {
            return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
        }
        //attribute missing /not expected
        else if (difference.getId() == DifferenceConstants.ATTR_NAME_NOT_FOUND_ID) {
            if (IGNORE_ATTRS.contains(difference.getTestNodeDetail().getValue())) {
                return RETURN_IGNORE_DIFFERENCE_NODES_IDENTICAL;
            }
        }

        return RETURN_ACCEPT_DIFFERENCE;
    }

    @Override
    public void skippedComparison(Node control, Node test) {
        //nothing to do
    }
}

à l'aide de DifferenceListener:

    XMLUnit.setIgnoreWhitespace(true);
    XMLUnit.setIgnoreDiffBetweenTextAndCDATA(true);

    Diff diff = new Diff(expectedDocument, obtainedDocument);
    diff.overrideDifferenceListener(new IgnoreVariableAttributesDifferenceListener(Arrays.asList("id", "uid"), true));

    XMLAssert.assertXMLIdentical("xml invalid", diff, true);