inital package check implementation (#53)

README.md

@@ -44,8 +44,10 @@ and [CX Templates](https://github.com/tracetronic/cx-templates).
 ## Features
 
 - Provides an easy integration and control of ECU-TEST and TRACE-CHECK with Jenkins
+- Enables perfoming package and project checks with rules defined in ECU-TEST. 
+  - [Custom-Checks](https://github.com/tracetronic/ecu-test_custom-checks) provides an easy way to configure and import these checks.
 - Enables the execution of ECU-TEST packages and projects with their respective configurations
-- Enable the upload of generated test reports to [TEST-GUIDE](https://www.tracetronic.com/products/test-guide/) 
+- Enables the upload of generated test reports to [TEST-GUIDE](https://www.tracetronic.com/products/test-guide/) 
 - Using "pipelines first" approach to improve the automated process and traceability
 
 ## Configuration
@@ -71,6 +73,10 @@ node('windows') {
     stage('Start Tools') {
         ttStartTool toolName: 'ECU-TEST', workspaceDir: './workspace', settingsDir: './settings'
     }
+    stage('Package Checks') {
+      ttCheckPackage testCasePath: 'sample.pkg'
+      ttCheckPackage testCasePath: 'sample.prj'
+    }
     stage('Test Execution') {
         ttRunProject testCasePath: 'sample.prj', testConfig: [tbcPath: 'sample.tbc', tcfPath: 'sample.tcf', constants: [[label: 'sample', value: '123']]]
         ttRunPackage testCasePath: 'sample.pkg', testConfig: [tbcPath: '', tcfPath: '', forceConfigurationReload: true, constants: [[label: 'sample', value: '\'sampleValue\'']]]

src/main/groovy/de/tracetronic/jenkins/plugins/ecutestexecution/RestApiClient.groovy

@@ -9,20 +9,23 @@ import de.tracetronic.cxs.generated.et.client.ApiClient
 import de.tracetronic.cxs.generated.et.client.ApiException
 import de.tracetronic.cxs.generated.et.client.Configuration
 import de.tracetronic.cxs.generated.et.client.api.ApiStatusApi
+import de.tracetronic.cxs.generated.et.client.api.ChecksApi
 import de.tracetronic.cxs.generated.et.client.api.ExecutionApi
 import de.tracetronic.cxs.generated.et.client.api.ReportApi
+import de.tracetronic.cxs.generated.et.client.model.CheckFinding
+import de.tracetronic.cxs.generated.et.client.model.CheckReport
+import de.tracetronic.cxs.generated.et.client.model.CheckExecutionOrder
+import de.tracetronic.cxs.generated.et.client.model.CheckExecutionStatus
 import de.tracetronic.cxs.generated.et.client.model.Execution
 import de.tracetronic.cxs.generated.et.client.model.ExecutionOrder
 import de.tracetronic.cxs.generated.et.client.model.ExecutionStatus
 import de.tracetronic.cxs.generated.et.client.model.ReportGeneration
 import de.tracetronic.cxs.generated.et.client.model.ReportGenerationOrder
 import de.tracetronic.cxs.generated.et.client.model.ReportGenerationStatus
 import de.tracetronic.cxs.generated.et.client.model.ReportInfo
-import de.tracetronic.cxs.generated.et.client.model.SimpleMessage
 import de.tracetronic.cxs.generated.et.client.model.TGUpload
 import de.tracetronic.cxs.generated.et.client.model.TGUploadOrder
 import de.tracetronic.cxs.generated.et.client.model.TGUploadStatus
-import hudson.model.TaskListener
 import org.apache.commons.lang.StringUtils
 
 class RestApiClient {
@@ -61,6 +64,27 @@ class RestApiClient {
         return alive
     }
 
+    /**
+     * This method performs the package check via the ChecksApi and returns the CheckResult.
+     * Throws ApiExceptions on error status codes.
+     * @param filepath the path to the package or project to be checked
+     * @return the check report
+     */
+    CheckReport runPackageCheck(String filepath) throws ApiException {
+        ChecksApi apiInstance = new ChecksApi(apiClient)
+        CheckExecutionOrder order = new CheckExecutionOrder().filePath(filepath)
+        String checkExecutionId = apiInstance.createCheckExecutionOrder(order).getCheckExecutionId()
+        Closure<Boolean> checkStatus = { CheckExecutionStatus response ->
+            response?.status in [null, 'WAITING', 'RUNNING']
+        }
+
+        while (checkStatus(apiInstance.getCheckExecutionStatus(checkExecutionId))) {
+            sleep(1000)
+        }
+        CheckReport checkReport = apiInstance.getCheckResult(checkExecutionId)
+        return checkReport
+    }
+
     Execution runTest(ExecutionOrder executionOrder, int timeout) {
         ExecutionApi apiInstance = new ExecutionApi(apiClient)
         apiInstance.createExecution(executionOrder)

src/main/groovy/de/tracetronic/jenkins/plugins/ecutestexecution/builder/AbstractTestBuilder.groovy

@@ -3,24 +3,21 @@ package de.tracetronic.jenkins.plugins.ecutestexecution.builder
 import de.tracetronic.cxs.generated.et.client.model.Execution
 import de.tracetronic.cxs.generated.et.client.model.ExecutionOrder
 import de.tracetronic.cxs.generated.et.client.model.ReportInfo
-import de.tracetronic.jenkins.plugins.ecutestexecution.ETInstallation
 import de.tracetronic.jenkins.plugins.ecutestexecution.RestApiClient
 import de.tracetronic.jenkins.plugins.ecutestexecution.configs.ExecutionConfig
 import de.tracetronic.jenkins.plugins.ecutestexecution.configs.TestConfig
+import de.tracetronic.jenkins.plugins.ecutestexecution.model.CheckPackageResult
 import de.tracetronic.jenkins.plugins.ecutestexecution.model.TestResult
+import de.tracetronic.jenkins.plugins.ecutestexecution.model.ToolInstallations
+import de.tracetronic.jenkins.plugins.ecutestexecution.steps.CheckPackageStep
 import de.tracetronic.jenkins.plugins.ecutestexecution.util.LogConfigUtil
-import de.tracetronic.jenkins.plugins.ecutestexecution.util.ProcessUtil
 import hudson.EnvVars
 import hudson.Launcher
-import hudson.model.Computer
-import hudson.model.Node
 import hudson.model.TaskListener
 import jenkins.security.MasterToSlaveCallable
 import org.apache.commons.lang.StringUtils
 import org.jenkinsci.plugins.workflow.steps.StepContext
 
-import java.util.concurrent.TimeoutException
-
 /**
  * Common base class for all test related steps implemented in this plugin.
  */
@@ -51,35 +48,33 @@ abstract class AbstractTestBuilder implements Serializable {
         return testConfig ? new TestConfig(testConfig) : null
     }
 
+    /**
+     * Performs CheckPackageStep if executePackageCheck option was set in the execution config and calls the execution
+     * of the package.
+     * @return TestResult
+     * results of the test execution
+     */
     TestResult runTest() {
-
-        def toolInstallations = getToolInstallationsOnNode()
+        TaskListener listener = context.get(TaskListener.class)
+        ToolInstallations toolInstallations = new ToolInstallations(context)
+
+        if (executionConfig.executePackageCheck){
+            CheckPackageStep step = new CheckPackageStep(testCasePath)
+            step.setExecutionConfig(executionConfig)
+            CheckPackageResult check_result = step.start(context).run()
+            if (executionConfig.stopOnError && check_result.result == "ERROR") {
+                listener.logger.println(
+                        "Skipping execution of ${testArtifactName} ${testCasePath} due to failed package checks"
+                )
+                return new TestResult(null, "ERROR",null)
+            }
+        }
 
         return context.get(Launcher.class).getChannel().call(new RunTestCallable(testCasePath,
-                context.get(EnvVars.class), context.get(TaskListener.class), executionConfig,
+                context.get(EnvVars.class), listener, executionConfig,
                 getTestArtifactName(), getLogConfig(), getExecutionOrderBuilder(), toolInstallations))
     }
 
-    private ArrayList<String> getToolInstallationsOnNode() {
-        /**
-         * This method gets the executable names of the tool installations on the node given by the context. Context is
-         * not reasonably available in the MasterToSlaveCallable, so all info which needs a context must be fetched
-         * outside.
-         *
-         * @return list of the executable names of the ECU-TEST installations on the respective node (can also be
-         * TRACE-CHECK executables)
-         */
-        Computer computer = context.get(Launcher).getComputer()
-        Node node = computer?.getNode()
-        EnvVars envVars = context.get(EnvVars)
-        TaskListener listener = context.get(TaskListener)
-        if(node) {
-            return ETInstallation.getAllExecutableNames(envVars, node, listener)
-        } else {
-            return null
-        }
-    }
-
     private static final class RunTestCallable extends MasterToSlaveCallable<TestResult, IOException> {
 
         private static final long serialVersionUID = 1L 
@@ -91,11 +86,11 @@ abstract class AbstractTestBuilder implements Serializable {
         private final ExecutionConfig executionConfig
         private final String testArtifactName
         private final LogConfigUtil configUtil
-        private final ArrayList<String> toolInstallations
+        private final ToolInstallations toolInstallations
 
         RunTestCallable(final String testCasePath, EnvVars envVars, TaskListener listener,
                         ExecutionConfig executionConfig, String testArtifactName, LogConfigUtil configUtil,
-                        ExecutionOrderBuilder executionOrderBuilder, ArrayList<String> toolInstallations) {
+                        ExecutionOrderBuilder executionOrderBuilder, ToolInstallations toolInstallations) {
             this.testCasePath = testCasePath
             this.envVars = envVars
             this.listener = listener
@@ -126,39 +121,14 @@ abstract class AbstractTestBuilder implements Serializable {
                 result = new TestResult(null, 'ERROR', null)
                 listener.logger.println("Executing ${testArtifactName} failed!")
                 if (executionConfig.stopOnError) {
-                    stopToolInstances()
+                    toolInstallations.stopToolInstances(executionConfig.timeout)
                     if (executionConfig.stopUndefinedTools) {
-                        stopTTInstances()
+                        toolInstallations.stopTTInstances(executionConfig.timeout)
                     }
                 }
             }
             listener.logger.println(result.toString())
-
             return result
         }
-
-        private stopToolInstances() {
-            int timeout = executionConfig.timeout
-            if (toolInstallations) {
-                if (ProcessUtil.killProcesses(toolInstallations, timeout)) {
-                    listener.logger.println('-> Tools stopped successfully.')
-                }
-                else {
-                    throw new TimeoutException("Timeout of ${timeout} seconds exceeded for stopping tool!")
-                }
-            } else {
-                listener.logger.println("No Tool Installations to stop were found. No processes killed.")
-            }
-        }
-
-        private stopTTInstances() {
-            int timeout = executionConfig.timeout
-            listener.logger.println("Stop TraceTronic tool instances.")
-            if (ProcessUtil.killTTProcesses(timeout)) {
-                listener.logger.println("Stopped TraceTronic tools successfully.")
-            } else {
-                throw new TimeoutException("Timeout of ${timeout} seconds exceeded for stopping TraceTronic tools!")
-            }
-        }
     }
 }

src/main/groovy/de/tracetronic/jenkins/plugins/ecutestexecution/configs/ExecutionConfig.groovy

@@ -23,19 +23,22 @@ class ExecutionConfig extends AbstractDescribableImpl<ExecutionConfig> implement
     private int timeout
     private boolean stopOnError
     private boolean stopUndefinedTools
+    private boolean executePackageCheck
 
 
     @DataBoundConstructor
     ExecutionConfig() {
         this.timeout = DEFAULT_TIMEOUT
         this.stopOnError = true
         this.stopUndefinedTools = true
+        this.executePackageCheck = false
     }
 
     ExecutionConfig(ExecutionConfig config) {
         this.timeout = config.getTimeout()
         this.stopOnError = config.isStopOnError()
         this.stopUndefinedTools = config.getStopUndefinedTools()
+        this.executePackageCheck = config.getExecutePackageCheck()
     }
 
     int getTimeout() {
@@ -56,6 +59,15 @@ class ExecutionConfig extends AbstractDescribableImpl<ExecutionConfig> implement
         this.stopOnError = stopOnError
     }
 
+    boolean getExecutePackageCheck() {
+        return executePackageCheck
+    }
+
+    @DataBoundSetter
+    void setExecutePackageCheck(boolean executePackageCheck) {
+        this.executePackageCheck = executePackageCheck
+    }
+
     boolean getStopUndefinedTools() {
         return stopUndefinedTools
     }

src/main/groovy/de/tracetronic/jenkins/plugins/ecutestexecution/model/CheckPackageResult.groovy

@@ -0,0 +1,68 @@
+package de.tracetronic.jenkins.plugins.ecutestexecution.model
+
+import org.jenkinsci.plugins.scriptsecurity.sandbox.whitelists.Whitelisted
+
+/**
+ * Class holding the result of a package check.
+ */
+class CheckPackageResult implements Serializable {
+
+    private static final long serialVersionUID = 1L
+
+    private final String result
+    private final String testCasePath
+    private final List<HashMap<String, String>> issues
+
+    /**
+     * Instantiates a new [CheckPackageResult].
+     * @param testCasePath
+     * the path to the file (package or project) where CheckPackageStep was executed on
+     * @param issues
+     * the issues contain hashmaps with filename as key and issue message as value
+     */
+    CheckPackageResult(String testCasePath, List<HashMap<String, String>> issues) {
+        this.result = (issues == null || issues.size()) ? "ERROR" : "SUCCESS"
+        this.testCasePath = testCasePath
+        this.issues = issues
+    }
+
+    /**
+     * @return result
+     */
+    @Whitelisted
+    String getResult() {
+        return result
+    }
+
+    /**
+     * @return the testCasePath
+     */
+    @Whitelisted
+    String getTestCasePath() {
+        return testCasePath
+    }
+
+    /**
+     * @return the issues
+     */
+    @Whitelisted
+    List<HashMap<String, String>> getIssues() {
+        return new ArrayList<HashMap<String, String>>(issues)
+    }
+
+    /**
+     * Returns a string representation of the object.
+     * @return package check result as string
+     */
+    @Override
+    String toString() {
+        String str = "-> result: ${result} \n"
+        if (issues && issues.size() != 0) {
+            str += "-> ${issues.size()} issues in ${testCasePath} \n"
+        }
+        for (issue in issues) {
+            str += "--> ${issue.filename}: ${issue.message}\n"
+        }
+        return str.stripIndent().trim()
+    }
+}