test

src/net/wooga/jenkins/pipeline/check/Nodes.groovy

@@ -0,0 +1,56 @@
+package net.wooga.jenkins.pipeline.check
+
+import net.wooga.jenkins.pipeline.check.steps.PackedStep
+import net.wooga.jenkins.pipeline.config.Platform
+import net.wooga.jenkins.pipeline.model.Docker
+
+class Nodes {
+
+    private Object jenkins
+    private Docker docker
+    private EnclosureCreator enclosureCreator
+
+    Nodes(Object jenkins, Docker docker, EnclosureCreator enclosureCreator) {
+        this.jenkins = jenkins
+        this.docker = docker
+        this.enclosureCreator = enclosureCreator
+    }
+
+    def withDocker(Platform platform, PackedStep mainCls, Closure catchCls = {throw it}, PackedStep finallyCls = {}) {
+        return enclosureCreator.atlasNode(platform.name,
+                platform.generateTestLabelsString(),
+                platform.testEnvironment,
+                withCheckout(platform.checkoutDirectory, { docker.runOnImage(mainCls) }),
+                catchCls,
+                withCleanup(platform.clearWs, finallyCls)
+        )
+    }
+
+    def simple(Platform platform, PackedStep mainClosure, Closure catchCls = {throw it}, PackedStep finallyCls = {}) {
+        return enclosureCreator.atlasNode(platform.name,
+                platform.generateTestLabelsString(),
+                platform.testEnvironment,
+                withCheckout(platform.checkoutDirectory, mainClosure),
+                catchCls,
+                withCleanup(platform.clearWs, finallyCls)
+        )
+    }
+
+    private PackedStep withCheckout(String checkoutDir, PackedStep step) {
+        return {
+            jenkins.dir(checkoutDir) {
+                jenkins.checkout(jenkins.scm)
+            }
+            step()
+        }
+    }
+
+    private PackedStep withCleanup(boolean hasCleanup, PackedStep step) {
+        return {
+            step()
+            if(hasCleanup) {
+                jenkins.cleanWs()
+            }
+        }
+    }
+}

src/net/wooga/jenkins/pipeline/config/GradleArgs.groovy

@@ -12,7 +12,7 @@ class GradleArgs {
 
 
     static GradleArgs fromConfigMap(Map config) {
-        def environment = new EnvVars((config.gradleEnvironment ?: [:]) as Map<String, ?>)
+        def environment = EnvVars.fromList((config.gradleEnvironment ?: []) as List<?>)
         def showStackTraces = (config.showStackTrace ?: false) as boolean
         def refreshDependencies = (config.refreshDependencies ?: false) as boolean
         return new GradleArgs(environment, config.logLevel as String, showStackTraces, refreshDependencies)

src/net/wooga/jenkins/pipeline/model/EnvVars.groovy

@@ -1,40 +1,53 @@
 package net.wooga.jenkins.pipeline.model
 
+import com.cloudbees.groovy.cps.NonCPS
+
 class EnvVars {
 
-    final Map<String, Closure<String>> environment
+    final List<?> environment
+
+    static EnvVars fromList(List<?> env) {
+        return new EnvVars(env)
+    }
+
+    EnvVars(List<?> environment) {
+        this.environment = environment
+    }
 
-    EnvVars(Map<String, ?> environment) {
-        this.environment = lazifyMap(environment)
+
+    List<String> resolveAsStrings() {
+        return environment.collect {
+            if(it instanceof Closure) {
+                return it.call().toString()
+            }
+            return it.toString()
+        }
     }
 
-    static Map<String, Closure<String>> lazifyMap(Map<String, ?> env) {
+//    def mapToTuples(Map map) {
+//        return map.collect { new Tuple2<>(it.key, it.value) }
+//    }
+    @NonCPS
+    List<List<?>>mapToList(Map map){
+        return map.collect { it ->[it.key, it.value]}
+    }
+
+
+    static Map<String, Closure> lazifyMap(Map<String, ?> env) {
         Map<String, Closure<String>> lazyMap = [:]
-        for(String key : env.keySet()) {
+        for(String key in env.keySet()) {
             if(env[key] instanceof Closure) {
                 lazyMap.put(key, env[key])
             } else {
                 def value = env.get(key)
-                lazyMap.put(key, { -> value })
+                lazyMap.put(key, { -> value?.toString() })
             }
         }
         return lazyMap
     }
 
-    List<String> resolveAsStrings() {
-        List<String> result = []
-        for(String key : environment.keySet()) {
-            Closure<String> lazyValue = environment[key]
-            def value = lazyValue?.call()
-            if(value != null) {
-                result += ["$key=$value"]
-            }
-        }
-        return result
-    }
-
-    Closure<String> getAt(String key) {
-        environment[key]
+    Object getAt(String key) {
+        environment.find{ it.first == key }
     }
 
 }

src/net/wooga/jenkins/pipeline/model/Gradle.groovy

@@ -31,7 +31,9 @@ class Gradle {
      */
     def wrapper(String command, Boolean returnStatus = false,
                 Boolean returnStdout = false) {
+        jenkins.echo "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         jenkins.withEnv(environment.resolveAsStrings()) {
+            jenkins.echo "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
             if (jenkins.isUnix()) {
                 return jenkins.sh(script: "./gradlew ${formatCommand(command)}", returnStdout: returnStdout, returnStatus: returnStatus)
             } else {

vars/gradleWrapper.groovy

@@ -1,13 +1,14 @@
 #!/usr/bin/env groovy
+import com.cloudbees.groovy.cps.NonCPS
 import net.wooga.jenkins.pipeline.model.EnvVars
 import net.wooga.jenkins.pipeline.model.Gradle
 
 /**
  * execute gradlew or gradlew.bat based on current os
  */
-def call(String command, Boolean returnStatus = false, Boolean returnStdout = false, Map<String, ?> environment=[:]) {
+def call(String command, Boolean returnStatus = false, Boolean returnStdout = false, List<?> environment=[]) {
     def gradle = Gradle.fromJenkins(this,
-                new EnvVars(environment),
+                EnvVars.fromList(environment),
                 params.LOG_LEVEL?: env.LOG_LEVEL as String,
                 params.STACK_TRACE? params.STACK_TRACE as Boolean : false,
                 params.REFRESH_DEPENDENCIES? params.REFRESH_DEPENDENCIES as Boolean : false)
@@ -18,7 +19,7 @@ def call(Map args) {
     call(args.command?.toString(),
         (args.returnStatus?: false) as Boolean,
         (args.returnStdout?: false) as Boolean,
-        (args.environment?: [:]) as Map<String, ?>
+        (args.environment?: []) as List<?>
     )
 }