tfwrapper 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f11f99f25e1c0f38ce5c79928b9b6434aee3445
-  data.tar.gz: b00feb3297fb625886ce712a76300b2251560e34
+  metadata.gz: f64138baa8e32b2b73782f96ed7170e8a0371296
+  data.tar.gz: 6ec9aa09e58490cd647815ae47b7461b1256edea
 SHA512:
-  metadata.gz: 2516206493b0e019dfeada871fef5e0f444c1eb128c7297daa73afea55ae261a1db4e28c9d213ba18e0d651c777d7ce35a481a8c3e9461a18a7a98de113e0863
-  data.tar.gz: f7e976dc8d51f1f0a68d9300d450626f424a6aa6a12c6af40229e8f187db1ccded5ebeb5f7884d4e7693eaf6f31446a5b0b31cec4c05c7e09b311b428e7e508b
+  metadata.gz: 9bbccee24517fe1bd91acd1cb32e0dd1a45da75d73b5eec356a227721af4a29842cdd07d37248754becc791a0778d5dd21cdc373ed6b1e26189ced595dc9ce22
+  data.tar.gz: 5d3fc8354620ae60100133a2cc01358edb9b562e36b8b0f31ceca9b6422da95df25906ae7f02856e7f4e50bcd2aa58a0faf3f31a3bf18e5d9f2773caa850bd3e

data/.rubocop.yml

@@ -1,8 +1,8 @@
 Metrics/AbcSize:
-  Max: 22
+  Max: 40
 
 Metrics/BlockLength:
-  Max: 1000
+  Max: 1300
 
 Metrics/ClassLength:
   Max: 500
@@ -10,6 +10,12 @@ Metrics/ClassLength:
 Metrics/MethodLength:
   Max: 100
 
+Metrics/PerceivedComplexity:
+  Max: 8
+
+Metrics/CyclomaticComplexity:
+  Max: 8
+
 # These are to compensate for some warnings that differ by
 # rubocop/ruby version
 Lint/UnneededDisable:
@@ -21,6 +27,11 @@ Style/MutableConstant:
     - 'lib/tfwrapper/version.rb'
     - 'spec/acceptance/acceptance_spec.rb'
 
-Layout/MultilineMethodCallIndentation:
+Style/MultilineMethodCallIndentation:
   Exclude:
     - 'spec/unit/raketasks_spec.rb'
+
+# Offense count: 28
+# Cop supports --auto-correct.
+Style/Proc:
+  Enabled: false

data/ChangeLog.md

@@ -1,3 +1,8 @@
+Version 0.4.0
+
+  - Add support for calling Procs at the beginning and end of each task.
+  - Documentation cleanup.
+
 Version 0.3.0
 
   - Add `tf:output` and `tf:output_json` Rake tasks

data/README.md

@@ -31,6 +31,8 @@ This Gem provides the following Rake tasks:
   ``bundle exec rake tf:destroy[aws_instance.foo[1],aws_instance.bar[2]]``; see the
   [destroy documentation](https://www.terraform.io/docs/commands/destroy.html) for more information.
 * __tf:write_tf_vars__ - used as a prerequisite for other tasks; write Terraform variables to file on disk
+* __tf:output__ - run ``terraform output``
+* __tf:output_json__ - run ``terraform output -json``
 
 ## Installation
 
@@ -236,6 +238,33 @@ TFWrapper::RakeTasks.install_tasks(
 )
 ```
 
+### Calling Procs At Beginning and End of Tasks
+
+Version 0.4.0 of tfwrapper introduced the ability to call arbitrary Ruby Procs from within the Rake tasks,
+at the beginning and end of the task (i.e. before and after the terraform-handling code within the task).
+This is accomplished via the ``:before_proc`` and ``:after_proc`` options, each taking a Proc instance.
+
+The Procs take two positional arguments; a ``String`` containing the full, namespaced name of the Rake task
+it was called from, and the ``String`` ``tf_dir`` argument passed to the TFWrapper::RakeTasks class (exactly as specified).
+
+This could be used for things such as showing the output of state after a terraform run,
+triggering a [tfenv](https://github.com/kamatama41/tfenv) installation, etc.
+
+```ruby
+require 'tfwrapper/raketasks'
+
+TFWrapper::RakeTasks.install_tasks(
+  '.',
+  before_proc: Proc.new do |taskname, tfdir|
+    next unless taskname == 'tf:apply' # example of only executing for apply task in default namespace
+    puts "Executing #{taskname} task with tfdir=#{tfdir}"
+  end,
+  after_proc: Proc.new do |taskname, tfdir|
+    puts "Executed #{taskname} task with tfdir=#{tfdir}"
+  end
+)
+```
+
 ### Environment Variables to Consul
 
 tfwrapper also includes functionality to push environment variables to Consul

data/lib/tfwrapper/raketasks.rb

@@ -7,11 +7,7 @@ require 'rubygems'
 require 'tfwrapper/version'
 
 module TFWrapper
-  # Generates Rake tasks for working with Terraform at Manheim.
-  #
-  # Before using this, the ``CONSUL_HOST`` environment variable must be set.
-  #
-  # __NOTE:__ Be sure to document all tasks in README.md
+  # Generates Rake tasks for working with Terraform.
   class RakeTasks
     include Rake::DSL if defined? Rake::DSL
 
@@ -19,7 +15,8 @@ module TFWrapper
       # set when installed
       attr_accessor :instance
 
-      # Install the Rake tasks for working with Terraform at Manheim.
+      # Install the Rake tasks for working with Terraform. For full parameter
+      # documentation, see {TFWrapper::RakeTasks#initialize}
       #
       # @param (see #initialize)
       def install_tasks(tf_dir, opts = {})
@@ -33,12 +30,11 @@ module TFWrapper
 
     attr_reader :tf_version
 
-    # Generate Rake tasks for working with Terraform at Manheim.
+    # Generate Rake tasks for working with Terraform.
     #
     # @param tf_dir [String] Terraform config directory, relative to Rakefile.
     #   Set to '.' if the Rakefile is in the same directory as the ``.tf``
     #   configuration files.
-    # @param [Hash] options to use when adding tasks
     # @option opts [Hash] :backend_config hash of Terraform remote state
     #   backend configuration options, to override or supplement those in
     #   the terraform configuration. See the
@@ -58,6 +54,15 @@ module TFWrapper
     #   write the environment variables used from ``tf_vars_from_env``
     #   and their values to JSON at this path in Consul. This should have
     #   the same naming constraints as ``consul_prefix``.
+    # @option opts [Proc] :before_proc Proc instance to call before executing
+    #   the body of each task. Called with two arguments, the String full
+    #   (namespaced) name of the task being executed, and ``tf_dir``. Returning
+    #   or breaking from this Proc will cause the task to not execute; to exit
+    #   the Proc early, use ``next``.
+    # @option opts [Proc] :after_proc Proc instance to call after executing
+    #   the body of each task. Called with two arguments, the String full
+    #   (namespaced) name of the task being executed, and ``tf_dir``. This will
+    #   not execute if the body of the task fails.
     def initialize(tf_dir, opts = {})
       # find the directory that contains the Rakefile
       rakedir = File.realpath(Rake.application.rakefile)
@@ -69,6 +74,22 @@ module TFWrapper
       @tf_extra_vars = opts.fetch(:tf_extra_vars, {})
       @backend_config = opts.fetch(:backend_config, {})
       @consul_url = opts.fetch(:consul_url, nil)
+      @before_proc = opts.fetch(:before_proc, nil)
+      if !@before_proc.nil? && !@before_proc.is_a?(Proc)
+        raise(
+          TypeError,
+          'TFWrapper::RakeTasks.initialize option :before_proc must be a ' \
+          'Proc instance, not a ' + @before_proc.class.name
+        )
+      end
+      @after_proc = opts.fetch(:after_proc, nil)
+      if !@after_proc.nil? && !@after_proc.is_a?(Proc)
+        raise(
+          TypeError,
+          'TFWrapper::RakeTasks.initialize option :after_proc must be a Proc ' \
+          'instance, not a ' + @after_proc.class.name
+        )
+      end
       # default to lowest possible version; this is set in the 'init' task
       @tf_version = Gem::Version.new('0.0.0')
       # rubocop:disable Style/GuardClause
@@ -105,7 +126,8 @@ module TFWrapper
     def install_init
       namespace nsprefix do
         desc 'Run terraform init with appropriate arguments'
-        task :init do
+        task :init do |t|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           TFWrapper::Helpers.check_env_vars(@tf_vars_from_env.values)
           @tf_version = check_tf_version
           cmd = [
@@ -117,6 +139,7 @@ module TFWrapper
             cmd = cmd + ' ' + "-backend-config='#{k}=#{v}'"
           end
           terraform_runner(cmd)
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -129,7 +152,8 @@ module TFWrapper
         task :plan, [:target] => [
           :"#{nsprefix}:init",
           :"#{nsprefix}:write_tf_vars"
-        ] do |_t, args|
+        ] do |t, args|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           cmd = cmd_with_targets(
             ['terraform', 'plan', "-var-file #{var_file_path}"],
             args[:target],
@@ -137,6 +161,7 @@ module TFWrapper
           )
 
           terraform_runner(cmd)
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -150,7 +175,8 @@ module TFWrapper
           :"#{nsprefix}:init",
           :"#{nsprefix}:write_tf_vars",
           :"#{nsprefix}:plan"
-        ] do |_t, args|
+        ] do |t, args|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           cmd_arr = %w[terraform apply]
           cmd_arr << '-auto-approve' if tf_version >= Gem::Version.new('0.10.0')
           cmd_arr << "-var-file #{var_file_path}"
@@ -162,6 +188,7 @@ module TFWrapper
           terraform_runner(cmd)
 
           update_consul_stack_env_vars unless @consul_env_vars_prefix.nil?
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -172,7 +199,8 @@ module TFWrapper
         task refresh: [
           :"#{nsprefix}:init",
           :"#{nsprefix}:write_tf_vars"
-        ] do
+        ] do |t|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           cmd = [
             'terraform',
             'refresh',
@@ -180,6 +208,7 @@ module TFWrapper
           ].join(' ')
 
           terraform_runner(cmd)
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -190,14 +219,18 @@ module TFWrapper
         task output: [
           :"#{nsprefix}:init",
           :"#{nsprefix}:refresh"
-        ] do
+        ] do |t|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           terraform_runner('terraform output')
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
         task output_json: [
           :"#{nsprefix}:init",
           :"#{nsprefix}:refresh"
-        ] do
+        ] do |t|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           terraform_runner('terraform output -json')
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -210,7 +243,8 @@ module TFWrapper
         task :destroy, [:target] => [
           :"#{nsprefix}:init",
           :"#{nsprefix}:write_tf_vars"
-        ] do |_t, args|
+        ] do |t, args|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           cmd = cmd_with_targets(
             ['terraform', 'destroy', '-force', "-var-file #{var_file_path}"],
             args[:target],
@@ -218,6 +252,7 @@ module TFWrapper
           )
 
           terraform_runner(cmd)
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end
@@ -234,7 +269,8 @@ module TFWrapper
     def install_write_tf_vars
       namespace nsprefix do
         desc "Write #{var_file_path}"
-        task :write_tf_vars do
+        task :write_tf_vars do |t|
+          @before_proc.call(t.name, @tf_dir) unless @before_proc.nil?
           tf_vars = terraform_vars
           puts 'Terraform vars:'
           tf_vars.sort.map do |k, v|
@@ -248,6 +284,7 @@ module TFWrapper
             f.write(tf_vars.to_json)
           end
           STDERR.puts "Terraform vars written to: #{var_file_path}"
+          @after_proc.call(t.name, @tf_dir) unless @after_proc.nil?
         end
       end
     end

data/lib/tfwrapper/version.rb

@@ -4,5 +4,5 @@ module TFWrapper
   # version of the Gem/module; used in the gemspec and in messages.
   # NOTE: When updating this, also update the version in the "Installation"
   # section of README.md
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/acceptance/acceptance_helpers.rb

@@ -4,10 +4,13 @@ require 'ffi'
 require 'faraday'
 require 'json'
 
-def cleanup_tf
-  fixture_dir = File.absolute_path(
+def fixture_dir
+  File.absolute_path(
     File.join(File.dirname(__FILE__), '..', 'fixtures')
   )
+end
+
+def cleanup_tf
   Dir.glob("#{fixture_dir}/**/.terraform").each do |d|
     FileUtils.rmtree(d) if File.directory?(d)
   end
@@ -73,7 +76,6 @@ class HashicorpFetcher
     true
   end
 
-  # rubocop:disable Metrics/AbcSize
   def fetch
     return File.realpath(bin_path) unless vendored_required?
     require 'open-uri'
@@ -102,7 +104,6 @@ class HashicorpFetcher
     raise StandardErrro, 'Error: wrong version' unless is_correct_version?
     File.realpath(bin_path)
   end
-  # rubocop:enable Metrics/AbcSize
 
   def is_correct_version?
     ver = `#{bin_path} version`.strip

data/spec/acceptance/acceptance_spec.rb

@@ -237,6 +237,26 @@ describe 'tfwrapper' do
           "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
         )
       end
+      it 'calls the before proc with the proper arguments before terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*Executing tf:apply task with tfdir=' \
+            "#{Regexp.escape(fixture_dir)}\/testTwo\/foo\/bar.*" \
+            'terraform_runner command: \'terraform apply.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
+      it 'calls the after proc with the proper arguments after terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*terraform_runner command: \'terraform apply.*Executed ' \
+            "tf:apply task with tfdir=#{Regexp.escape(fixture_dir)}" \
+            '\/testTwo\/foo\/bar.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
       it 'writes the vars file' do
         expect(File.file?(@varpath)).to be(true)
         c = File.open(@varpath, 'r').read
@@ -341,6 +361,19 @@ describe 'tfwrapper' do
         expect(@out_err).to include('foo_variable = fooval')
         expect(@out_err).to include('bar_variable = barval')
       end
+      it 'calls the procs with the proper arguments in proper order' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*Executing tf:output task with tfdir=' \
+            "#{Regexp.escape(fixture_dir)}\/testTwo\/foo\/bar\n" \
+            'bar_variable = barval' + "\n" \
+            'foo_variable = fooval' + "\n" \
+            'Executed tf:output task with tfdir=' \
+            "#{Regexp.escape(fixture_dir)}\/testTwo\/foo\/bar\n",
+            Regexp::MULTILINE
+          )
+        )
+      end
     end
   end
   context 'testThree - TF with namespaces', order: :defined do
@@ -471,6 +504,26 @@ describe 'tfwrapper' do
           .to include('consul_keys.testThreeFoo')
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
+      it 'calls the before proc with the proper arguments before terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*Executing tf:apply task with tfdir=' \
+            "#{Regexp.escape(fixture_dir)}\/testThree\/foo.*" \
+            'terraform_runner command: \'terraform apply.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
+      it 'calls the after proc with the proper arguments after terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*terraform_runner command: \'terraform apply.*Executed ' \
+            "tf:apply task with tfdir=#{Regexp.escape(fixture_dir)}" \
+            '\/testThree\/foo.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
     end
     describe 'tf:output' do
       before(:all) do
@@ -551,6 +604,26 @@ describe 'tfwrapper' do
           .to include('consul_keys.testThreeBar')
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
+      it 'calls the before proc with the proper arguments before terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*Executing bar_tf:apply task with tfdir=' \
+            "#{Regexp.escape(fixture_dir)}\/testThree\/bar.*" \
+            'terraform_runner command: \'terraform apply.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
+      it 'calls the after proc with the proper arguments after terraform' do
+        expect(@out_err).to match(
+          Regexp.new(
+            '.*terraform_runner command: \'terraform apply.*Executed ' \
+            "bar_tf:apply task with tfdir=#{Regexp.escape(fixture_dir)}" \
+            '\/testThree\/bar.*',
+            Regexp::MULTILINE
+          )
+        )
+      end
     end
     describe 'bar_tf:output' do
       before(:all) do

data/spec/fixtures/testThree/Rakefile

@@ -2,25 +2,34 @@
 
 require 'tfwrapper/raketasks'
 
-# @option opts [String] :consul_url URL to access Consul at, for the
-#   ``:consul_env_vars_prefix`` option.
-# @option opts [String] :consul_env_vars_prefix if specified and not nil,
-#   write the environment variables used from ``tf_vars_from_env``
-#   and their values to JSON at this path in Consul. This should have
-#   the same naming constraints as ``consul_prefix``.
+# we want to get real streaming output
+STDOUT.sync = true
+STDERR.sync = true
 
 TFWrapper::RakeTasks.install_tasks(
   'foo',
   backend_config: { 'path' => 'terraform/testThreeFoo' },
   tf_vars_from_env: { 'foo' => 'FOO' },
-  tf_extra_vars: { 'bar' => 'barONEval' }
+  tf_extra_vars: { 'bar' => 'barONEval' },
+  before_proc: Proc.new do |taskname, tfdir|
+    puts "Executing #{taskname} task with tfdir=#{tfdir}"
+  end,
+  after_proc: Proc.new do |taskname, tfdir|
+    puts "Executed #{taskname} task with tfdir=#{tfdir}"
+  end
 )
 
 TFWrapper::RakeTasks.install_tasks(
   'bar',
   namespace_prefix: 'bar',
   tf_vars_from_env: { 'foo' => 'FOO' },
-  tf_extra_vars: { 'bar' => 'barTWOval' }
+  tf_extra_vars: { 'bar' => 'barTWOval' },
+  before_proc: Proc.new do |taskname, tfdir|
+    puts "Executing #{taskname} task with tfdir=#{tfdir}"
+  end,
+  after_proc: Proc.new do |taskname, tfdir|
+    puts "Executed #{taskname} task with tfdir=#{tfdir}"
+  end
 )
 
 TFWrapper::RakeTasks.install_tasks(
@@ -28,5 +37,11 @@ TFWrapper::RakeTasks.install_tasks(
   namespace_prefix: 'baz',
   tf_vars_from_env: { 'foo' => 'FOO' },
   consul_url: 'http://127.0.0.1:8500',
-  consul_env_vars_prefix: 'vars/testThreeBaz'
+  consul_env_vars_prefix: 'vars/testThreeBaz',
+  before_proc: Proc.new do |taskname, tfdir|
+    puts "Executing #{taskname} task with tfdir=#{tfdir}"
+  end,
+  after_proc: Proc.new do |taskname, tfdir|
+    puts "Executed #{taskname} task with tfdir=#{tfdir}"
+  end
 )

data/spec/fixtures/testTwo/Rakefile

@@ -2,11 +2,21 @@
 
 require 'tfwrapper/raketasks'
 
+# we want to get real streaming output
+STDOUT.sync = true
+STDERR.sync = true
+
 TFWrapper::RakeTasks.install_tasks(
   'foo/bar',
   backend_config: {
     'path' => "terraform/testTwo/#{ENV['TFSUFFIX']}"
   },
   tf_vars_from_env: { 'foo' => 'FOO' },
-  tf_extra_vars: { 'bar' => 'barval' }
+  tf_extra_vars: { 'bar' => 'barval' },
+  before_proc: Proc.new do |taskname, tfdir|
+    puts "Executing #{taskname} task with tfdir=#{tfdir}"
+  end,
+  after_proc: Proc.new do |taskname, tfdir|
+    puts "Executed #{taskname} task with tfdir=#{tfdir}"
+  end
 )

data/spec/unit/raketasks_spec.rb

@@ -12,6 +12,8 @@ require 'rubygems'
 describe TFWrapper::RakeTasks do
   subject do
     allow(Rake.application).to receive(:rakefile).and_return('Rakefile')
+    allow(Rake.application).to receive(:original_dir)
+      .and_return('/path/to/rakedir')
     allow(File).to receive(:realpath) { |p| p }
     subj = TFWrapper::RakeTasks.new('tfdir')
     subj.instance_variable_set('@tf_dir', 'tfdir')
@@ -62,6 +64,8 @@ describe TFWrapper::RakeTasks do
       expect(cls.instance_variable_get('@consul_url')).to eq(nil)
       expect(cls.instance_variable_get('@tf_version'))
         .to eq(Gem::Version.new('0.0.0'))
+      expect(cls.instance_variable_get('@before_proc')).to eq(nil)
+      expect(cls.instance_variable_get('@after_proc')).to eq(nil)
     end
     it 'sets options' do
       allow(ENV).to receive(:[])
@@ -69,12 +73,22 @@ describe TFWrapper::RakeTasks do
       allow(Rake.application).to receive(:rakefile)
         .and_return('/path/to')
       allow(File).to receive(:realpath) { |p| p.sub('../', '') }
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to_not receive(:foo)
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to_not receive(:foo)
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
       cls = TFWrapper::RakeTasks.new(
         'tf/dir',
         consul_env_vars_prefix: 'cvprefix',
         tf_vars_from_env: { 'foo' => 'bar' },
         tf_extra_vars: { 'baz' => 'blam' },
-        consul_url: 'foobar'
+        consul_url: 'foobar',
+        before_proc: bproc,
+        after_proc: aproc
       )
       expect(cls.instance_variable_get('@tf_dir'))
         .to eq('/path/to/tf/dir')
@@ -86,6 +100,38 @@ describe TFWrapper::RakeTasks do
         .to eq('baz' => 'blam')
       expect(cls.instance_variable_get('@backend_config')).to eq({})
       expect(cls.instance_variable_get('@consul_url')).to eq('foobar')
+      expect(cls.instance_variable_get('@before_proc')).to eq(bproc)
+      expect(cls.instance_variable_get('@after_proc')).to eq(aproc)
+    end
+    context 'when before_proc is not a proc or nil' do
+      it 'raises an error' do
+        allow(ENV).to receive(:[])
+        allow(ENV).to receive(:[]).with('CONSUL_HOST').and_return('chost')
+        allow(ENV).to receive(:[]).with('ENVIRONMENT').and_return('myenv')
+        allow(ENV).to receive(:[]).with('PROJECT').and_return('myproj')
+        allow(Rake.application).to receive(:rakefile)
+          .and_return('/rake/dir/Rakefile')
+        allow(File).to receive(:realpath) { |p| p.sub('../', '') }
+        allow(File).to receive(:file?).and_return(true)
+        expect { TFWrapper::RakeTasks.new('tfdir', before_proc: 'foo') }
+          .to raise_error(
+            TypeError,
+            /before_proc must be a Proc instance, not a String/
+          )
+      end
+    end
+    context 'when after_proc is not a proc or nil' do
+      it 'raises an error' do
+        allow(Rake.application).to receive(:original_dir)
+          .and_return('/rake/dir')
+        allow(Rake.application).to receive(:rakefile).and_return('Rakefile')
+        allow(File).to receive(:realpath) { |p| p }
+        expect { TFWrapper::RakeTasks.new('tfdir', after_proc: 'foo') }
+          .to raise_error(
+            TypeError,
+            /after_proc must be a Proc instance, not a String/
+          )
+      end
     end
     context 'when consul_url is nil but consul_env_vars_prefix is not' do
       it 'raises an error' do
@@ -290,6 +336,40 @@ describe TFWrapper::RakeTasks do
       expect(subject.instance_variable_get(:@tf_version))
         .to eq(Gem::Version.new('0.10.2'))
     end
+    it 'calls before_proc if not nil' do
+      Rake.application['tf:init'].clear_prerequisites
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:init', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      allow(TFWrapper::Helpers).to receive(:check_env_vars)
+      allow(ENV).to receive(:[])
+      subject.instance_variable_set('@backend_config', {})
+      allow(subject).to receive(:terraform_runner)
+      allow(subject).to receive(:check_tf_version)
+        .and_return(Gem::Version.new('0.10.2'))
+      Rake.application['tf:init'].invoke
+    end
+    it 'calls after_proc if not nil' do
+      Rake.application['tf:init'].clear_prerequisites
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:init', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      allow(TFWrapper::Helpers).to receive(:check_env_vars)
+      allow(ENV).to receive(:[])
+      subject.instance_variable_set('@backend_config', {})
+      allow(subject).to receive(:terraform_runner)
+      allow(subject).to receive(:check_tf_version)
+        .and_return(Gem::Version.new('0.10.2'))
+      Rake.application['tf:init'].invoke
+    end
   end
   describe '#install_plan' do
     # these let/before/after come from bundler's gem_helper_spec.rb
@@ -339,6 +419,32 @@ describe TFWrapper::RakeTasks do
         'tar.get[1]', 't.gt[2]', 'my.target[3]'
       )
     end
+    it 'calls before_proc if not nil' do
+      Rake.application['tf:plan'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:plan', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:plan'].invoke
+    end
+    it 'calls after_proc if not nil' do
+      Rake.application['tf:plan'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:plan', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:plan'].invoke
+    end
   end
   describe '#install_apply' do
     # these let/before/after come from bundler's gem_helper_spec.rb
@@ -359,6 +465,34 @@ describe TFWrapper::RakeTasks do
         .to eq(%w[tf:init tf:write_tf_vars tf:plan])
       expect(Rake.application['tf:apply'].arg_names).to eq([:target])
     end
+    it 'calls before_proc if not nil' do
+      Rake.application['tf:apply'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+      allow(subject).to receive(:update_consul_stack_env_vars)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:apply', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:apply'].invoke
+    end
+    it 'calls after_proc if not nil' do
+      Rake.application['tf:apply'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+      allow(subject).to receive(:update_consul_stack_env_vars)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:apply', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:apply'].invoke
+    end
     context 'terraform version 0.9.5' do
       before(:each) do
         allow(subject).to receive(:tf_version)
@@ -481,6 +615,32 @@ describe TFWrapper::RakeTasks do
         .with('terraform refresh -var-file file.tfvars.json')
       Rake.application['tf:refresh'].invoke
     end
+    it 'calls before_proc if not nil' do
+      Rake.application['tf:refresh'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:refresh', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:refresh'].invoke
+    end
+    it 'calls after_proc if not nil' do
+      Rake.application['tf:refresh'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:refresh', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:refresh'].invoke
+    end
   end
   describe '#install_destroy' do
     # these let/before/after come from bundler's gem_helper_spec.rb
@@ -530,6 +690,32 @@ describe TFWrapper::RakeTasks do
         'tar.get[1]', 't.gt[2]', 'my.target[3]'
       )
     end
+    it 'calls before_proc if not nil' do
+      Rake.application['tf:destroy'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:destroy', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:destroy'].invoke
+    end
+    it 'calls after_proc if not nil' do
+      Rake.application['tf:destroy'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:destroy', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:destroy'].invoke
+    end
   end
   describe '#install_write_tf_vars' do
     # these let/before/after come from bundler's gem_helper_spec.rb
@@ -575,6 +761,48 @@ describe TFWrapper::RakeTasks do
           .once.with('Terraform vars written to: file.tfvars.json')
         Rake.application['tf:write_tf_vars'].invoke
       end
+      it 'calls before_proc if not nil' do
+        vars = {
+          'foo' => 'bar',
+          'baz' => 'blam',
+          'aws_access_key' => 'ak'
+        }
+        allow(subject).to receive(:terraform_vars).and_return(vars)
+        allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+        f_dbl = double(File)
+        allow(File).to receive(:open).and_yield(f_dbl)
+        allow(f_dbl).to receive(:write)
+
+        before_dbl = double
+        allow(before_dbl).to receive(:foo)
+        expect(before_dbl).to receive(:foo).once
+          .with('tf:write_tf_vars', 'tfdir')
+        bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+        subject.instance_variable_set('@before_proc', bproc)
+
+        Rake.application['tf:write_tf_vars'].invoke
+      end
+      it 'calls after_proc if not nil' do
+        vars = {
+          'foo' => 'bar',
+          'baz' => 'blam',
+          'aws_access_key' => 'ak'
+        }
+        allow(subject).to receive(:terraform_vars).and_return(vars)
+        allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+        f_dbl = double(File)
+        allow(File).to receive(:open).and_yield(f_dbl)
+        allow(f_dbl).to receive(:write)
+
+        after_dbl = double
+        allow(after_dbl).to receive(:foo)
+        expect(after_dbl).to receive(:foo).once
+          .with('tf:write_tf_vars', 'tfdir')
+        aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+        subject.instance_variable_set('@after_proc', aproc)
+
+        Rake.application['tf:write_tf_vars'].invoke
+      end
     end
     context 'when ns_prefix is specified' do
       let!(:rake_application) { Rake.application }
@@ -620,6 +848,50 @@ describe TFWrapper::RakeTasks do
           .once.with('Terraform vars written to: foo_file.tfvars.json')
         Rake.application['foo_tf:write_tf_vars'].invoke
       end
+      it 'calls before_proc if not nil' do
+        vars = {
+          'foo' => 'bar',
+          'baz' => 'blam',
+          'aws_access_key' => 'ak'
+        }
+        allow(subject).to receive(:terraform_vars).and_return(vars)
+        allow(subject).to receive(:var_file_path)
+          .and_return('foo_file.tfvars.json')
+        f_dbl = double(File)
+        allow(File).to receive(:open).and_yield(f_dbl)
+        allow(f_dbl).to receive(:write)
+
+        before_dbl = double
+        allow(before_dbl).to receive(:foo)
+        expect(before_dbl).to receive(:foo).once
+          .with('foo_tf:write_tf_vars', 'tfdir')
+        bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+        subject.instance_variable_set('@before_proc', bproc)
+
+        Rake.application['foo_tf:write_tf_vars'].invoke
+      end
+      it 'calls after_proc if not nil' do
+        vars = {
+          'foo' => 'bar',
+          'baz' => 'blam',
+          'aws_access_key' => 'ak'
+        }
+        allow(subject).to receive(:terraform_vars).and_return(vars)
+        allow(subject).to receive(:var_file_path)
+          .and_return('foo_file.tfvars.json')
+        f_dbl = double(File)
+        allow(File).to receive(:open).and_yield(f_dbl)
+        allow(f_dbl).to receive(:write)
+
+        after_dbl = double
+        allow(after_dbl).to receive(:foo)
+        expect(after_dbl).to receive(:foo).once
+          .with('foo_tf:write_tf_vars', 'tfdir')
+        aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+        subject.instance_variable_set('@after_proc', aproc)
+
+        Rake.application['foo_tf:write_tf_vars'].invoke
+      end
     end
   end
   describe '#install_output' do
@@ -649,6 +921,32 @@ describe TFWrapper::RakeTasks do
         .with('terraform output')
       Rake.application['tf:output'].invoke
     end
+    it 'output calls before_proc if not nil' do
+      Rake.application['tf:output'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:output', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:output'].invoke
+    end
+    it 'output calls after_proc if not nil' do
+      Rake.application['tf:output'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:output', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:output'].invoke
+    end
     it 'adds the output_json task' do
       expect(Rake.application['tf:output_json']).to be_instance_of(Rake::Task)
       expect(Rake.application['tf:output_json'].prerequisites)
@@ -662,6 +960,32 @@ describe TFWrapper::RakeTasks do
         .with('terraform output -json')
       Rake.application['tf:output_json'].invoke
     end
+    it 'output_json calls before_proc if not nil' do
+      Rake.application['tf:output_json'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      before_dbl = double
+      allow(before_dbl).to receive(:foo)
+      expect(before_dbl).to receive(:foo).once.with('tf:output_json', 'tfdir')
+      bproc = Proc.new { |a, b| before_dbl.foo(a, b) }
+      subject.instance_variable_set('@before_proc', bproc)
+
+      Rake.application['tf:output_json'].invoke
+    end
+    it 'output_json calls after_proc if not nil' do
+      Rake.application['tf:output_json'].clear_prerequisites
+      allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+      allow(subject).to receive(:terraform_runner)
+
+      after_dbl = double
+      allow(after_dbl).to receive(:foo)
+      expect(after_dbl).to receive(:foo).once.with('tf:output_json', 'tfdir')
+      aproc = Proc.new { |a, b| after_dbl.foo(a, b) }
+      subject.instance_variable_set('@after_proc', aproc)
+
+      Rake.application['tf:output_json'].invoke
+    end
   end
   describe '#terraform_vars' do
     it 'builds a hash and sets overrides' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tfwrapper
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - jantman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: retries