Issue 175: Pass terraform plan file to apply

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Unreleased
 
 * [Issue #293](https://github.com/manheim/terraform-pipeline/issues/293) withEnv & withGlobalEnv docs
+* [Issue #175](https://github.com/manheim/terraform-pipeline/issues/175) Pass terraform plan output to apply
 
 # v5.10
 

README.md

@@ -117,6 +117,7 @@ The example above gives you a bare-bones pipeline, and there may be Jenkinsfile
 * [CrqPlugin](./docs/CrqPlugin.md): Use the manheim_remedier gem to open automated Change Requests.
 * [DestroyPlugin](./docs/DestroyPlugin.md): Use this to change the pipeline functionality to `terraform destroy`. (Requires manual confirmation)
 * [GithubPRPlanPlugin](./docs/GithubPRPlanPlugin.md): Use this to post Terraform plan results in the comments of a Github PullRequest.
+* [PassPlanFilePlugin](./docs/PassPlanFilePlugin.md): Pass the plan file into apply stage
 * [PlanOnlyPlugin](./docs/PlanOnlyPlugin.md): Use this to change the pipeline functionality to `terraform plan` only.
 * [TargetPlugin](./docs/TargetPlugin.md): set `-target` parameter for terraform plan and apply.
 * [TerraformDirectoryPlugin](./docs/TerraformDirectoryPlugin.md): Change the default directory containing your terraform code.

docs/PassPlanFilePlugin.md

@@ -0,0 +1,28 @@
+## [PassPlanFilePlugin](../src/PassPlanFilePlugin.groovy)
+
+Enable this plugin to pass the plan file output to `terraform apply`.
+
+This plugin stashes the plan file during the `plan` step.
+When `apply` is called, the plan file is unstashed and passed as an argument.
+
+
+```
+// Jenkinsfile
+@Library(['terraform-pipeline@v3.10']) _
+
+Jenkinsfile.init(this, env)
+
+// Pass the plan file to 'terraform apply'
+PassPlanFilePlugin.init()
+
+def validate = new TerraformValidateStage()
+
+def destroyQa = new TerraformEnvironmentStage('qa')
+def destroyUat = new TerraformEnvironmentStage('uat')
+def destroyProd = new TerraformEnvironmentStage('prod')
+
+validate.then(destroyQa)
+        .then(destroyUat)
+        .then(destroyProd)
+        .build()
+```

src/PassPlanFilePlugin.groovy

@@ -0,0 +1,50 @@
+import static TerraformEnvironmentStage.PLAN
+import static TerraformEnvironmentStage.APPLY
+
+class PassPlanFilePlugin implements TerraformPlanCommandPlugin, TerraformApplyCommandPlugin, TerraformEnvironmentStagePlugin {
+
+    public static void init() {
+        PassPlanFilePlugin plugin = new PassPlanFilePlugin()
+
+        TerraformEnvironmentStage.addPlugin(plugin)
+        TerraformPlanCommand.addPlugin(plugin)
+        TerraformApplyCommand.addPlugin(plugin)
+    }
+
+    @Override
+    public void apply(TerraformEnvironmentStage stage) {
+        stage.decorate(PLAN,  stashPlan(stage.getEnvironment()))
+        stage.decorate(APPLY, unstashPlan(stage.getEnvironment()))
+    }
+
+    @Override
+    public void apply(TerraformPlanCommand command) {
+        String env = command.getEnvironment()
+        command.withArgument("-out=tfplan-" + env)
+    }
+
+    @Override
+    public void apply(TerraformApplyCommand command) {
+        String env = command.getEnvironment()
+        command.withDirectory("tfplan-" + env)
+    }
+
+    public Closure stashPlan(String env) {
+        return { closure ->
+            closure()
+            String planFile = "tfplan-" + env
+            echo "Stashing ${planFile} file"
+            stash name: planFile, includes: planFile
+        }
+    }
+
+    public Closure unstashPlan(String env) {
+        return { closure ->
+            String planFile = "tfplan-" + env
+            echo "Unstashing ${planFile} file"
+            unstash planFile
+            closure()
+        }
+    }
+
+}

test/DummyJenkinsfile.groovy

@@ -57,4 +57,10 @@ class DummyJenkinsfile {
         closure.delegate = this
         closure()
     }
+    public stash(args) {
+        println "DummyJenkinsfile.stash(${args})"
+    }
+    public unstash(args) {
+        println "DummyJenkinsfile.unstash(${args})"
+    }
 }

test/PassPlanFilePluginTest.groovy

@@ -0,0 +1,134 @@
+import static org.hamcrest.Matchers.containsString
+import static org.hamcrest.Matchers.hasItem
+import static org.hamcrest.Matchers.instanceOf
+import static org.junit.Assert.assertThat
+import static org.junit.Assert.assertTrue
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.mock;
+import org.junit.Test
+import org.junit.Before
+import org.junit.After
+import org.junit.runner.RunWith
+import de.bechte.junit.runners.context.HierarchicalContextRunner
+
+@RunWith(HierarchicalContextRunner.class)
+class PassPlanFilePluginTest {
+    @Before
+    void resetJenkinsEnv() {
+        Jenkinsfile.instance = mock(Jenkinsfile.class)
+        when(Jenkinsfile.instance.getEnv()).thenReturn([:])
+    }
+
+    private configureJenkins(Map config = [:]) {
+        Jenkinsfile.instance = mock(Jenkinsfile.class)
+        when(Jenkinsfile.instance.getEnv()).thenReturn(config.env ?: [:])
+    }
+
+    public class Init {
+        @After
+        void resetPlugins() {
+            TerraformPlanCommand.resetPlugins()
+            TerraformApplyCommand.resetPlugins()
+            TerraformEnvironmentStage.reset()
+        }
+
+        @Test
+        void modifiesTerraformEnvironmentStageCommand() {
+            PassPlanFilePlugin.init()
+
+            Collection actualPlugins = TerraformEnvironmentStage.getPlugins()
+            assertThat(actualPlugins, hasItem(instanceOf(PassPlanFilePlugin.class)))
+        }
+
+        @Test
+        void modifiesTerraformPlanCommand() {
+            PassPlanFilePlugin.init()
+
+            Collection actualPlugins = TerraformPlanCommand.getPlugins()
+            assertThat(actualPlugins, hasItem(instanceOf(PassPlanFilePlugin.class)))
+        }
+
+        @Test
+        void modifiesTerraformApplyCommand() {
+            PassPlanFilePlugin.init()
+
+            Collection actualPlugins = TerraformApplyCommand.getPlugins()
+            assertThat(actualPlugins, hasItem(instanceOf(PassPlanFilePlugin.class)))
+        }
+
+    }
+
+    public class Apply {
+
+        @Test
+        void decoratesTheTerraformEnvironmentStage()  {
+            PassPlanFilePlugin plugin = new PassPlanFilePlugin()
+            def environment = spy(new TerraformEnvironmentStage())
+            plugin.apply(environment)
+
+            verify(environment, times(1)).decorate(eq(TerraformEnvironmentStage.PLAN), any(Closure.class))
+            verify(environment, times(1)).decorate(eq(TerraformEnvironmentStage.APPLY), any(Closure.class))
+        }
+
+        @Test
+        void addsArgumentToTerraformPlan() {
+            PassPlanFilePlugin plugin = new PassPlanFilePlugin()
+            TerraformPlanCommand command = new TerraformPlanCommand("dev")
+            plugin.apply(command)
+
+            String result = command.toString()
+            assertThat(result, containsString("-out=tfplan-dev"))
+        }
+
+        @Test
+        void addsArgumentToTerraformApply() {
+            PassPlanFilePlugin plugin = new PassPlanFilePlugin()
+            TerraformApplyCommand command = new TerraformApplyCommand("dev")
+            plugin.apply(command)
+
+            String result = command.toString()
+            assertThat(result, containsString("tfplan-dev"))
+        }
+
+    }
+
+    public class StashPlan {
+
+        @Test
+        void runsStashPlan() {
+            def wasCalled = false
+            def passedClosure = { -> wasCalled = true }
+            def plugin = new PassPlanFilePlugin()
+
+            def stashClosure = plugin.stashPlan('dev')
+            stashClosure.delegate = new DummyJenkinsfile()
+            stashClosure.call(passedClosure)
+
+            assertTrue(wasCalled)
+        }
+
+    }
+
+    public class UnstashPlan {
+
+        @Test
+        void runsUnstashPlan() {
+            def wasCalled = false
+            def passedClosure = { -> wasCalled = true }
+            def plugin = new PassPlanFilePlugin()
+
+            def unstashClosure = plugin.unstashPlan('dev')
+            unstashClosure.delegate = new DummyJenkinsfile()
+            unstashClosure.call(passedClosure)
+
+            assertTrue(wasCalled)
+        }
+
+    }
+
+}