Share initEnvironment and resetEnvironment logic to use in multiple Declarations

Author: Willem Borgesius

src/main/groovy/com/lesfurets/jenkins/unit/declarative/GenericPipelineDeclaration.groovy

@@ -57,25 +57,43 @@ abstract class GenericPipelineDeclaration {
         closure.call()
     }
 
-    def stage(String name,
+    def stage(String stageName,
               @DelegatesTo(strategy = DELEGATE_FIRST, value = StageDeclaration) Closure closure) {
-        this.stages.put(name, createComponent(StageDeclaration, closure).with { it.name = name; it })
+        this.stages.put(stageName, createComponent(StageDeclaration, closure).with { it.name = stageName; it })
     }
 
     def execute(Object delegate) {
+        Map envValuestoRestore = [:]
+
         // set environment
         if (this.environment) {
-            Binding subBinding = new Binding()
-            subBinding.metaClass.invokeMissingProperty = { propertyName ->
-                delegate.getProperty(propertyName)
-            }
-            subBinding.metaClass.setProperty = { String propertyName, Object newValue ->
-                (delegate.env as Map).put(propertyName, newValue)
+            envValuestoRestore = initEnvironment(this.environment, delegate)
+        }
+        resetEnvironment(envValuestoRestore, delegate)
+    }
+
+    public static Map initEnvironment(Closure environment, Object delegate) {
+        Map envValuestoRestore = [:]
+        Binding subBinding = new Binding()
+        subBinding.metaClass.invokeMissingProperty = { propertyName ->
+            delegate.getProperty(propertyName)
+        }
+        subBinding.metaClass.setProperty = { String propertyName, Object newValue ->
+            if (delegate.hasProperty(propertyName)) {
+                envValuestoRestore.put(propertyName, delegate.getProperty(propertyName))
             }
-            def envClosure = this.environment.rehydrate(subBinding, delegate, this)
-            envClosure.resolveStrategy = DELEGATE_FIRST
-            envClosure.call()
+            (delegate.env as Map).put(propertyName, newValue)
         }
+        def envClosure = environment.rehydrate(subBinding, delegate, this)
+        envClosure.resolveStrategy = DELEGATE_FIRST
+        envClosure.call()
+        return envValuestoRestore
     }
 
+    public static resetEnvironment(LinkedHashMap envValuestoRestore, delegate) {
+        envValuestoRestore.entrySet().forEach { entry ->
+            def envMap = delegate.env as Map
+            envMap.put(entry.getKey(), entry.getValue())
+        }
+    }
 }

src/main/groovy/com/lesfurets/jenkins/unit/declarative/StageDeclaration.groovy

@@ -1,51 +1,26 @@
 package com.lesfurets.jenkins.unit.declarative
 
 
-import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.createComponent
 import static com.lesfurets.jenkins.unit.declarative.GenericPipelineDeclaration.executeWith
-import static groovy.lang.Closure.*
+import static groovy.lang.Closure.DELEGATE_FIRST
 
-class StageDeclaration {
+class StageDeclaration extends GenericPipelineDeclaration {
 
-    AgentDeclaration agent
-    Closure environment
     String name
     Closure steps
     WhenDeclaration when
     ParallelDeclaration parallel
-    PostDeclaration post
     boolean failFast = false
     List<Closure> options = []
-    Map<String, StageDeclaration> stages = [:]
 
     StageDeclaration(String name) {
         this.name = name
     }
 
-    def agent(Object o) {
-        this.agent = new AgentDeclaration().with { it.label = o; it }
-    }
-
-    def agent(@DelegatesTo(strategy = DELEGATE_FIRST, value = AgentDeclaration) Closure closure) {
-        this.agent = createComponent(AgentDeclaration, closure)
-    }
-
-    def environment(Closure closure) {
-        this.environment = closure
-    }
-
-    def post(@DelegatesTo(strategy = DELEGATE_FIRST, value = PostDeclaration) Closure closure) {
-        this.post = createComponent(PostDeclaration, closure)
-    }
-
     def steps(Closure closure) {
         this.steps = closure
     }
 
-    def stages(@DelegatesTo(DeclarativePipeline) Closure closure) {
-        closure.call()
-    }
-
     def failFast(boolean failFast) {
         this.failFast = failFast
     }
@@ -63,8 +38,6 @@ class StageDeclaration {
     }
 
     def execute(Object delegate) {
-        Map envValuestoRestore = [:]
-
         String name = this.name
         this.options.each {
             executeWith(delegate, it)
@@ -79,26 +52,16 @@ class StageDeclaration {
         }
 
         if (!when || when.execute(delegate)) {
-            // Set environment for stage
+            Map envValuestoRestore = [:]
+
+            // set environment
             if (this.environment) {
-                Binding subBinding = new Binding()
-                subBinding.metaClass.invokeMissingProperty = { propertyName ->
-                    delegate.getProperty(propertyName)
-                }
-                subBinding.metaClass.setProperty = { String propertyName, Object newValue ->
-                    if(delegate.hasProperty(propertyName)){
-                        envValuestoRestore.put(propertyName, delegate.getProperty(propertyName))
-                    }
-                    (delegate.env as Map).put(propertyName, newValue)
-                }
-                def envClosure = this.environment.rehydrate(subBinding, delegate, this)
-                envClosure.resolveStrategy = DELEGATE_FIRST
-                envClosure.call()
+                envValuestoRestore = initEnvironment(this.environment, delegate)
             }
 
             // TODO handle credentials
             this.stages.entrySet().forEach { stageEntry ->
-                stageEntry.getValue().execute(delegate)
+                stageEntry.value.execute(delegate)
             }
             if(steps) {
                 Closure stageBody = { agent?.execute(delegate) } >> steps.rehydrate(delegate, this, this)
@@ -108,13 +71,10 @@ class StageDeclaration {
             if (post) {
                 this.post.execute(delegate)
             }
+            resetEnvironment(envValuestoRestore, delegate)
         } else {
             executeWith(delegate, { echo "Skipping stage $name" })
         }
-        envValuestoRestore.entrySet().forEach { entry ->
-            def envMap = delegate.env as Map
-            envMap.put(entry.getKey(), entry.getValue())
-        }
     }
 
 }