results - Cómo acceder a los conteos de prueba de Junit en el proyecto Jenkins Pipeline

result analyzer

Question

Acabo de empezar con Jenkins

Mi proyecto de estilo libre solía informar resultados de pruebas de JUnit en Slack como este

MyJenkinsFreestyle - #79 Unstable after 4 min 59 sec (Open)
Test Status:
Passed: 2482, Failed: 13, Skipped: 62

Ahora me he mudado de la misma forma al proyecto de canalización, y todo está bien, excepto que las notificaciones de Slack no tienen estado de prueba

done MyPipelineProject #68 UNSTABLE

Entiendo que tengo que construir el mensaje para enviar a Slack, y lo he hecho anteriormente por ahora.

El único problema es cómo leo el estado de la prueba: el conteo pasado, el conteo fallido, etc. Esto se denomina "resumen de la prueba" en la commit complemento de holgura de Jenkins, y aquí está la captura de pantalla

Entonces, ¿cómo accedo a las pruebas / detalles de Junit en el proyecto Jenkins Pipeline? - Para que estos se informen en las notificaciones.

ACTUALIZACIÓN: En el proyecto Freestyle, la propia notificación de Slack tiene el "resumen de la prueba", y no hay opción para optar (o no) por el resumen de la prueba.

En el proyecto Pipeline, mi comando "junit" para "Publicar resultados de prueba de JUnit" es antes de enviar una notificación de Slack.

Así que en el código esas líneas se ven así (estas son las últimas líneas de la última etapa):

bat runtests.bat
junit ''junitreport/xml/TEST*.xml''
slackSend channel: ''#testschannel'', color: ''normal'', message: "done ${env.JOB_NAME} ${env.BUILD_NUMBER} (<${env.BUILD_URL}|Open>)";

Answer 1

A partir de esta presentación de Cloudbees, descubrí que debería ser posible a través del objeto "build". Tiene codigo como

def testResult = build.testResultAction
def total = testResult.totalCount

Pero currentBuild no proporciona acceso a testResultAction.

Así que seguí buscando y encontré esta publicación "reaccionar en pruebas fallidas en el script de canalización" . Allí Robert Sandell ha dado "propina profesional".

Consejo profesional, requiere alguna "lista blanca personalizada":

AbstractTestResultAction testResultAction = currentBuild.rawBuild.getAction(AbstractTestResultAction.class)
if (testResultAction != null) {
echo "Tests: ${testResultAction.failCount} / ${testResultAction.failureDiffString} failures of ${testResultAction.totalCount}./n/n"
}

Esto funcionó a la perfección, solo que tuve que deseleccionar la casilla de verificación "Groovy sandbox". Ahora tengo estos en el registro de compilación

Tests: 11 / ±0 failures of 2624

Ahora usaré esto para preparar la cadena para notificarlo con los resultados de las pruebas.

ACTUALIZAR:

Finalmente, la función que utilicé para obtener una salida como la siguiente (tenga en cuenta que la "falla de fallo" después de las pruebas fallidas es muy útil)

Test Status:
Passed: 2628, Failed: 6 / ±0, Skipped: 0

Es el siguiente:

import hudson.tasks.test.AbstractTestResultAction
@NonCPS
def testStatuses() {
def testStatus = ""
AbstractTestResultAction testResultAction = currentBuild.rawBuild.getAction(AbstractTestResultAction.class)
if (testResultAction != null) {
def total = testResultAction.totalCount
def failed = testResultAction.failCount
def skipped = testResultAction.skipCount
def passed = total - failed - skipped
testStatus = "Test Status:/n Passed: ${passed}, Failed: ${failed} ${testResultAction.failureDiffString}, Skipped: ${skipped}"
if (failed == 0) {
currentBuild.result = ''SUCCESS''
}
}
return testStatus
}

ACTUALIZACIÓN 2018-04-19

Tenga en cuenta que lo anterior requiere un manual de "lista blanca" de los métodos utilizados. Aquí es cómo puede hacer una lista blanca de todos los métodos de una sola vez

Actualizar manualmente la lista blanca ...

Salida Jenkins

Cree / actualice% USERPROFILE% .jenkins / scriptApproval.xml con el siguiente contenido

<?xml version=''1.0'' encoding=''UTF-8''?>
<scriptApproval plugin="[email protected]">
<approvedScriptHashes>
</approvedScriptHashes>
<approvedSignatures>
<string>method hudson.model.Actionable getAction java.lang.Class</string>
<string>method hudson.model.Cause getShortDescription</string>
<string>method hudson.model.Run getCauses</string>
<string>method hudson.tasks.test.AbstractTestResultAction getFailCount</string>
<string>method hudson.tasks.test.AbstractTestResultAction getFailureDiffString</string>
<string>method hudson.tasks.test.AbstractTestResultAction getSkipCount</string>
<string>method hudson.tasks.test.AbstractTestResultAction getTotalCount</string>
<string>method org.jenkinsci.plugins.workflow.support.steps.build.RunWrapper getRawBuild</string>
</approvedSignatures>
<aclApprovedSignatures/>
<approvedClasspathEntries/>
<pendingScripts/>
<pendingSignatures/>
<pendingClasspathEntries/>
</scriptApproval>

• Reiniciar Jenkins
• y luego verifique que la "aprobación de script" tenga aprobadas las entradas anteriores
• NOTA: Es lo que es importante. Por lo tanto, si el archivo de aprobación de script ya está allí, entonces generalmente deberá asegurarse de los contenidos de la etiqueta.

Answer 2

En primer lugar, gracias por las respuestas anteriores. Me ahorraron mucho tiempo, usé la solución propuesta en mi canalización. Sin embargo, no usé "listas blancas" y funciona bien. Utilizo bibliotecas compartidas para la canalización de Jenkins y aquí hay una parte de esa biblioteca compartida con canalización y el uso de métodos para obtener recuentos:

import hudson.model.*
import jenkins.model.*
import hudson.tasks.test.AbstractTestResultAction
def call(Closure body) {
...
def emailTestReport = ""
pipeline {
...
stages{
stage(''Test''){
...
post {
always {
junit ''tests.xml''
script {
AbstractTestResultAction testResultAction = currentBuild.rawBuild.getAction(AbstractTestResultAction.class)
if (testResultAction != null) {
def totalNumberOfTests = testResultAction.totalCount
def failedNumberOfTests = testResultAction.failCount
def failedDiff = testResultAction.failureDiffString
def skippedNumberOfTests = testResultAction.skipCount
def passedNumberOfTests = totalNumberOfTests - failedNumberOfTests - skippedNumberOfTests
emailTestReport = "Tests Report:/n Passed: ${passedNumberOfTests}; Failed: ${failedNumberOfTests} ${failedDiff}; Skipped: ${skippedNumberOfTests} out of ${totalNumberOfTests} "
}
}
mail to: ''[email protected]'',
subject: "Tests are finished: ${currentBuild.fullDisplayName}",
body: "Tests are finished ${env.BUILD_URL}/n Test Report: ${emailTestReport} "
}
}
}
}
}
}

ps Si creo emailTestRepot como una variable local dentro del script "sección" obtengo la siguiente excepción:

an exception which occurred:
in field locals
in field parent
in field caller
in field e
in field program
in field threads
in object org.jenkinsci.plugins.workflow.cps.CpsThreadGroup@11cd92de
Caused: java.io.NotSerializableException: hudson.tasks.junit.TestResultAction
...

Luché mucho tratando de arreglar esa excepción java.io.NotSerializableException. Como entendí, necesitaba usar la "lista blanca" para evitar NotSerializableException. Pero realmente no quería hacerlo y cuando me moví "def emailTestReport" fuera de la tubería, funcionó bien.

Answer 3

Para ampliar la respuesta de @vikramsjn, esto es lo que uso para obtener el resumen de la prueba en mi archivo Jenkins :

import hudson.tasks.test.AbstractTestResultAction
import hudson.model.Actionable
@NonCPS
def getTestSummary = { ->
def testResultAction = currentBuild.rawBuild.getAction(AbstractTestResultAction.class)
def summary = ""
if (testResultAction != null) {
def total = testResultAction.getTotalCount()
def failed = testResultAction.getFailCount()
def skipped = testResultAction.getSkipCount()
summary = "Test results:/n/t"
summary = summary + ("Passed: " + (total - failed - skipped))
summary = summary + (", Failed: " + failed)
summary = summary + (", Skipped: " + skipped)
} else {
summary = "No tests found"
}
return summary
}

Luego uso este método para crear una instancia de mi variable testSummary :

def testSummary = getTestSummary()

Esto devolverá algo similar a:

"Test results:
Passed: 123, Failed: 0, Skipped: 0"