JUnit XML-Formatspezifikation, die Hudson unterstützt

Ich habe Hudson als continuous integration server und ich wollen, verwenden Sie die option 'Publish JUnit test result report". Aber ich bin nicht xUnit-tools für die Prüfung, anstatt, dass ich über die shell-Skripte, die tests ausführen und die Ergebnisse zurückgeben, im einfachen format. Ich bin am überlegen, ein Skript, das verwandelt sich diese Ergebnisse auf den JUnit-format. Also ich bin interessant, wie sich die JUnit-Datei Aussehen muss?

Kommentar zu dem Problem
Jeder Grund, nicht mit JUnit? Diese tests können automatisiert werden, in eine Vielzahl von Moden, die über eine Vielzahl von tools, cmd, UI, etc... Kommentarautor: Aaron McIver
@AaronMcIver: Shell-Skripte sind ziemlich gut bei der Ausführung von tests auf (Sprache, die Java nicht). Wie würden Sie verwenden JUnit? Kommentarautor: Ben Voigt
@BenVoigt ich hatte zunächst angenommen, dass der OP hatte Java beteiligt und war auf der Suche nach bypass JUnit als Test-harness. Dies ist wahrscheinlich nicht der Fall ist nach der überprüfung der Frage. Es scheint, dass code.google.com/p/shell2junit kann einen gewissen nutzen für die OP nach einen zweiten Blick. Kommentarautor: Aaron McIver
Entlang der Linien von shell2unit hier ist eine JAXB-Klasse, die ich erstellt, Parsen/Ausgabe JUnit-XML-Code: gist.github.com/agentgt/8583649 Kommentarautor: Adam Gent

InformationsquelleAutor der Frage krvladislav | 2011-02-07

  1. 107

    Ich habe eine ähnliche Sache vor ein paar Monaten, und es stellte sich heraus das einfache format war genug für Hudson zu akzeptieren, es als ein test-Protokoll:

    <testsuite tests="3">
    <testcase classname="foo1" name="ASuccessfulTest"/>
    <testcase classname="foo2" name="AnotherSuccessfulTest"/>
    <testcase classname="foo3" name="AFailingTest">
        <failure type="NotEnoughFoo"> details about failure </failure>
    </testcase>
</testsuite>

    Diese Frage Antworten mit mehr details: Spec. für JUnit-XML-Ausgabe

    InformationsquelleAutor der Antwort Anders Lindahl

  2. 79

    Ich habe mir einfach die junit-4.xsd, die von anderen verlinkt und verwendet ein tool namens XMLSpear konvertieren des Schemas auf eine leere XML-Datei mit den Optionen unten gezeigt. Dies ist der (leicht bereinigt) Ergebnis:

    <?xml version="1.0" encoding="UTF-8"?>
<testsuites disabled="" errors="" failures="" name="" tests="" time="">
    <testsuite disabled="" errors="" failures="" hostname="" id=""
               name="" package="" skipped="" tests="" time="" timestamp="">
        <properties>
            <property name="" value=""/>
        </properties>
        <testcase assertions="" classname="" name="" status="" time="">
            <skipped/>
            <error message="" type=""/>
            <failure message="" type=""/>
            <system-out/>
            <system-err/>
        </testcase>
        <system-out/>
        <system-err/>
    </testsuite>
</testsuites>

    Einige dieser Elemente können mehrfach vorkommen:

    • Es kann nur einen testsuites element, denn das ist, wie XML funktioniert, aber es können mehrere testsuite Elemente innerhalb der testsuites element.
    • Jeder properties element kann mehrere property Kinder.
    • Jeder testsuite element kann mehrere testcase Kinder.
    • Jeder testcase element kann mehrere error, failure, system-out oder system-err Kinder.

    JUnit XML-Formatspezifikation, die Hudson unterstützt

    InformationsquelleAutor der Antwort Todd Mazierski

  3. 24

    Den top Antwort der Frage Anders Lindahl bezieht sich auf eine xsd-Datei.

    Persönlich fand ich dieser xsd-Datei auch sehr nützlich (ich erinnere mich nicht, wie ich fand). Es sieht ein bisschen weniger einschüchternd, und so weit wie ich es benutzt habe, alle Elemente und Attribute, die scheinen erkannt zu werden, die von Jenkins (v1.451)

    Eine Sache, obwohl: beim hinzufügen von mehreren <failure ... Elemente, nur eines wurde zurückbehalten in Jenkins. Beim erstellen der xml-Datei, die ich nun verketten Sie alle Fehler in einem.

    Update 2016-11 Der link ist nun gebrochen. Eine bessere alternative ist diese Seite aus cubic.org: JUnit-XML-Berichte-Datei-format, wo eine schöne Anstrengung unternommen wurde, um eine sinnvolle dokumentiert Beispiel. Beispiel-und xsd-unten kopiert, aber Ihre Seite sieht waay schöner.

    Beispiel JUnit-XML-Datei

    <?xml version="1.0" encoding="UTF-8"?>
<!-- a description of the JUnit XML format and how Jenkins parses it. See also junit.xsd -->

<!-- if only a single testsuite element is present, the testsuites
     element can be omitted. All attributes are optional. -->
<testsuites disabled="" <!-- total number of disabled tests from all testsuites. -->
            errors=""   <!-- total number of tests with error result from all testsuites. -->
            failures="" <!-- total number of failed tests from all testsuites. -->
            name=""
            tests=""    <!-- total number of successful tests from all testsuites. -->
            time=""     <!-- time in seconds to execute all test suites. -->
        >

  <!-- testsuite can appear multiple times, if contained in a testsuites element.
       It can also be the root element. -->
  <testsuite name=""      <!-- Full (class) name of the test for non-aggregated testsuite documents.
                               Class name without the package for aggregated testsuites documents. Required -->
         tests=""     <!-- The total number of tests in the suite, required. -->
         disabled=""  <!-- the total number of disabled tests in the suite. optional -->
             errors=""    <!-- The total number of tests in the suite that errored. An errored test is one that had an unanticipated problem,
                               for example an unchecked throwable; or a problem with the implementation of the test. optional -->
             failures=""  <!-- The total number of tests in the suite that failed. A failure is a test which the code has explicitly failed
                               by using the mechanisms for that purpose. e.g., via an assertEquals. optional -->
             hostname=""  <!-- Host on which the tests were executed. 'localhost' should be used if the hostname cannot be determined. optional -->
         id=""        <!-- Starts at 0 for the first testsuite and is incremented by 1 for each following testsuite -->
         package=""   <!-- Derived from testsuite/@name in the non-aggregated documents. optional -->
         skipped=""   <!-- The total number of skipped tests. optional -->
         time=""      <!-- Time taken (in seconds) to execute the tests in the suite. optional -->
         timestamp="" <!-- when the test was executed in ISO 8601 format (2014-01-21T16:17:18). Timezone may not be specified. optional -->
         >

    <!-- Properties (e.g., environment settings) set during test
     execution. The properties element can appear 0 or once. -->
    <properties>
      <!-- property can appear multiple times. The name and value attributres are required. -->
      <property name="" value=""/>
    </properties>

    <!-- testcase can appear multiple times, see /testsuites/testsuite@tests -->
    <testcase name=""       <!-- Name of the test method, required. -->
          assertions="" <!-- number of assertions in the test case. optional -->
          classname=""  <!-- Full class name for the class the test method is in. required -->
          status=""
          time=""       <!-- Time taken (in seconds) to execute the test. optional -->
          >

      <!-- If the test was not executed or failed, you can specify one
           the skipped, error or failure elements. -->

      <!-- skipped can appear 0 or once. optional -->
      <skipped/>

      <!-- Indicates that the test errored. An errored test is one
           that had an unanticipated problem. For example an unchecked
           throwable or a problem with the implementation of the
           test. Contains as a text node relevant data for the error,
           for example a stack trace. optional -->
      <error message="" <!-- The error message. e.g., if a java exception is thrown, the return value of getMessage() -->
         type=""    <!-- The type of error that occured. e.g., if a java execption is thrown the full class name of the exception. -->
         ></error>

      <!-- Indicates that the test failed. A failure is a test which
       the code has explicitly failed by using the mechanisms for
       that purpose. For example via an assertEquals. Contains as
       a text node relevant data for the failure, e.g., a stack
       trace. optional -->
      <failure message="" <!-- The message specified in the assert. -->
           type=""    <!-- The type of the assert. -->
           ></failure>

      <!-- Data that was written to standard out while the test was executed. optional -->
      <system-out></system-out>

      <!-- Data that was written to standard error while the test was executed. optional -->
      <system-err></system-err>
    </testcase>

    <!-- Data that was written to standard out while the test suite was executed. optional -->
    <system-out></system-out>
    <!-- Data that was written to standard error while the test suite was executed. optional -->
    <system-err></system-err>
  </testsuite>
</testsuites>

    JUnit-XSD-Datei

    <?xml version="1.0" encoding="UTF-8" ?>
<!-- from https://svn.jenkins-ci.org/trunk/hudson/dtkit/dtkit-format/dtkit-junit-model/src/main/resources/com/thalesgroup/dtkit/junit/model/xsd/junit-4.xsd -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

    <xs:element name="failure">
        <xs:complexType mixed="true">
            <xs:attribute name="type" type="xs:string" use="optional"/>
            <xs:attribute name="message" type="xs:string" use="optional"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="error">
        <xs:complexType mixed="true">
            <xs:attribute name="type" type="xs:string" use="optional"/>
            <xs:attribute name="message" type="xs:string" use="optional"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="properties">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="property" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:element name="property">
        <xs:complexType>
            <xs:attribute name="name" type="xs:string" use="required"/>
            <xs:attribute name="value" type="xs:string" use="required"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="skipped" type="xs:string"/>
    <xs:element name="system-err" type="xs:string"/>
    <xs:element name="system-out" type="xs:string"/>

    <xs:element name="testcase">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="skipped" minOccurs="0" maxOccurs="1"/>
                <xs:element ref="error" minOccurs="0" maxOccurs="unbounded"/>
                <xs:element ref="failure" minOccurs="0" maxOccurs="unbounded"/>
                <xs:element ref="system-out" minOccurs="0" maxOccurs="unbounded"/>
                <xs:element ref="system-err" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
            <xs:attribute name="name" type="xs:string" use="required"/>
            <xs:attribute name="assertions" type="xs:string" use="optional"/>
            <xs:attribute name="time" type="xs:string" use="optional"/>
            <xs:attribute name="classname" type="xs:string" use="optional"/>
            <xs:attribute name="status" type="xs:string" use="optional"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="testsuite">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="properties" minOccurs="0" maxOccurs="1"/>
                <xs:element ref="testcase" minOccurs="0" maxOccurs="unbounded"/>
                <xs:element ref="system-out" minOccurs="0" maxOccurs="1"/>
                <xs:element ref="system-err" minOccurs="0" maxOccurs="1"/>
            </xs:sequence>
            <xs:attribute name="name" type="xs:string" use="required"/>
            <xs:attribute name="tests" type="xs:string" use="required"/>
            <xs:attribute name="failures" type="xs:string" use="optional"/>
            <xs:attribute name="errors" type="xs:string" use="optional"/>
            <xs:attribute name="time" type="xs:string" use="optional"/>
            <xs:attribute name="disabled" type="xs:string" use="optional"/>
            <xs:attribute name="skipped" type="xs:string" use="optional"/>
            <xs:attribute name="timestamp" type="xs:string" use="optional"/>
            <xs:attribute name="hostname" type="xs:string" use="optional"/>
            <xs:attribute name="id" type="xs:string" use="optional"/>
            <xs:attribute name="package" type="xs:string" use="optional"/>
        </xs:complexType>
    </xs:element>

    <xs:element name="testsuites">
        <xs:complexType>
            <xs:sequence>
                <xs:element ref="testsuite" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
            <xs:attribute name="name" type="xs:string" use="optional"/>
            <xs:attribute name="time" type="xs:string" use="optional"/>
            <xs:attribute name="tests" type="xs:string" use="optional"/>
            <xs:attribute name="failures" type="xs:string" use="optional"/>
            <xs:attribute name="disabled" type="xs:string" use="optional"/>
            <xs:attribute name="errors" type="xs:string" use="optional"/>
        </xs:complexType>
    </xs:element>

</xs:schema>

    InformationsquelleAutor der Antwort parvus

  4. 23

    Konnte ich nicht finden gute Informationen auf dieser, so habe ich einige Versuch und Irrtum. Die folgenden Attribute und Felder (und nur diese) erkannt werden, die von Jenkins (v1.585).

    <?xml version="1.0" encoding="UTF-8"?>
<testsuite>

  <!-- if your classname does not include a dot, the package defaults to "(root)" -->
  <testcase name="my testcase" classname="my package.my classname" time="29">

    <!-- If the test didn't pass, specify ONE of the following 3 cases -->

    <!-- option 1 --> <skipped />
    <!-- option 2 --> <failure message="my failure message">my stack trace</failure>
    <!-- option 3 --> <error message="my error message">my crash report</error>

    <system-out>my STDOUT dump</system-out>

    <system-err>my STDERR dump</system-err>

  </testcase>

</testsuite>

    (Ich begann mit diese Beispiel XML-Dokument und arbeitete nach hinten.)

    InformationsquelleAutor der Antwort Ian

  5. 4

    Es gibt mehrere schemas für "JUnit" und "xUnit" - Ergebnisse.

    Bitte beachten Sie, dass es mehrere Versionen des Schemas in der Nutzung von Jenkins xunit-plugin (die aktuelle neuste version ist junit-10.xsd fügt support für Erlang/OTP-Junit-format).

    Einige testing-frameworks sowie "xUnit"-Stil reporting-plugins verwenden auch Ihre eigene "geheime Soße" zu generieren "xUnit"-Berichte können nicht mit einem bestimmten schema (bitte Lesen: Sie versuchen, aber die tools nicht überprüfen, Sie gegen eines schema). Python unittests in Jenkins? gibt einen schnellen Vergleich von mehreren dieser Bibliotheken und leichte Unterschiede zwischen der xml-Berichte erzeugt.

    InformationsquelleAutor der Antwort dnozay

  6. 4

    Grundstruktur
    Hier ist ein Beispiel für eine JUnit-output-Datei und zeigt ein überspringen und scheiterte Ergebnis als auch ein einzelnes Ergebnis bestanden.

    <?xml version="1.0" encoding="UTF-8"?>
<testsuites>
   <testsuite name="JUnitXmlReporter" errors="0" tests="0" failures="0" time="0" timestamp="2013-05-24T10:23:58" />
   <testsuite name="JUnitXmlReporter.constructor" errors="0" skipped="1" tests="3" failures="1" time="0.006" timestamp="2013-05-24T10:23:58">
      <properties>
         <property name="java.vendor" value="Sun Microsystems Inc." />
         <property name="compiler.debug" value="on" />
         <property name="project.jdk.classpath" value="jdk.classpath.1.6" />
      </properties>
      <testcase classname="JUnitXmlReporter.constructor" name="should default path to an empty string" time="0.006">
         <failure message="test failure">Assertion failed</failure>
      </testcase>
      <testcase classname="JUnitXmlReporter.constructor" name="should default consolidate to true" time="0">
         <skipped />
      </testcase>
      <testcase classname="JUnitXmlReporter.constructor" name="should default useDotNotation to true" time="0" />
   </testsuite>
</testsuites>

    Unten ist die dokumentierte Struktur eines typischen JUnit-XML-Bericht. Beachten Sie, dass ein Bericht kann enthalten 1 oder mehrere test-suite. Jeder test-suite verfügt über eine Reihe von Eigenschaften (recording-Umgebung Informationen). Jeder test-suite enthält auch 1 oder mehrere test-Fall und jeder Testfall enthält entweder eine übersprungen, Ausfall oder Fehler-Knoten, wenn der test nicht bestanden. Wenn der Testfall bestanden hat, dann wird es nicht enthalten keine Knoten. Für mehr details, welche Attribute gelten für jeden Knoten, konsultieren Sie bitte den folgenden Abschnitt "Schema".

    <testsuites>        => the aggregated result of all junit testfiles
  <testsuite>       => the output from a single TestSuite
    <properties>    => the defined properties at test execution
      <property>    => name/value pair for a single property
      ...
    </properties>
    <error></error> => optional information, in place of a test case - normally if the tests in the suite could not be found etc.
    <testcase>      => the results from executing a test method
      <system-out>  => data written to System.out during the test run
      <system-err>  => data written to System.err during the test run
      <skipped/>    => test was skipped
      <failure>     => test failed
      <error>       => test encountered an error
    </testcase>
    ...
  </testsuite>
  ...
</testsuites>

    InformationsquelleAutor der Antwort Nayana Adassuriya

  7. 1

    Gute Antworten hier auf die Verwendung von python: (es gibt viele Möglichkeiten, es zu tun)
    Python unittests in Jenkins?

    IMHO der beste Weg ist schreiben python-unittest-tests und installieren pytest (so etwas wie "yum install pytest') py.testen installiert.
    Dann tests wie dieser: 'py.test --junitxml results.xml test.py'. Sie können jeden unittest python-Skript und bekommen jUnit-xml-Ergebnisse.

    https://docs.python.org/2.7/library/unittest.html

    In den jenkins build-Konfiguration Post-build-Aktionen Hinzufügen "Publish JUnit test result report" - Aktion mit result.xml und jeder weitere test Ergebnis-Dateien, die Sie produzieren.

    InformationsquelleAutor der Antwort gaoithe

  8. 1

    Habe ich beschlossen, zu veröffentlichen eine neue Antwort, weil einige bereits vorhandene Antworten sind veraltet oder unvollständig.

    Zunächst: es gibt nichts wie JUnit XML Format Specification einfach, weil JUnit nicht produzieren jede Art von XML-oder HTML-Bericht.

    Den XML-Bericht generation kommt selbst aus der Ant-JUnit-task/Maven-Surefire-Plugin/Gradle (je nachdem, was Sie verwenden für die Ausführung von tests). Das XML-report-format wurde erstmals von Ant und später angepasst durch Maven (und Gradle).

    Wenn jemand braucht einfach eine offizielle XML-format dann:

    1. Es existiert ein schema für ein maven-surefire-generierte XML-Bericht, und es kann hier gefunden werden: surefire-test-Bericht.xsd.
    2. Für eine Ameise generierte XML ist ein 3rd-party-schema zur Verfügung hier (aber es könnte etwas veraltet).

    Hoffe, es hilft jemand.

    InformationsquelleAutor der Antwort G. Demecki

Schreibe einen Kommentar