tfwrapper 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 546f4a0d5cfe06c3e1606071f6c09c74752d6ef0
-  data.tar.gz: 52178cde8c11eed2bed48df05c086ef9517d62c6
+  metadata.gz: 4f11f99f25e1c0f38ce5c79928b9b6434aee3445
+  data.tar.gz: b00feb3297fb625886ce712a76300b2251560e34
 SHA512:
-  metadata.gz: 296ea36c9f2c02ebe4fed3b94bd69f3e47bb31f938980e8b96ff7d2528e1b2db63d9d9934394cb2a3fdb83bda0507cdaa238ec6425fe8830d4466c6097704fce
-  data.tar.gz: 4d2ac178cdd25438debf5add32f007f76d1ca99b23d04dfa29e26d90ef1d819c8ceb6172e6f4c93e09893daa1ca02ccb4fa2ae2dd1e70d9cab09b79baa0281c1
+  metadata.gz: 2516206493b0e019dfeada871fef5e0f444c1eb128c7297daa73afea55ae261a1db4e28c9d213ba18e0d651c777d7ce35a481a8c3e9461a18a7a98de113e0863
+  data.tar.gz: f7e976dc8d51f1f0a68d9300d450626f424a6aa6a12c6af40229e8f187db1ccded5ebeb5f7884d4e7693eaf6f31446a5b0b31cec4c05c7e09b311b428e7e508b

data/.gitignore

@@ -13,6 +13,7 @@
 /vendor/
 .terraform
 build.tfvars.json
+**/terraform.tfstate.backup
 
 # Used by dotenv library to load environment variables.
 # .env

data/.rubocop.yml

@@ -20,3 +20,7 @@ Style/MutableConstant:
   Exclude:
     - 'lib/tfwrapper/version.rb'
     - 'spec/acceptance/acceptance_spec.rb'
+
+Layout/MultilineMethodCallIndentation:
+  Exclude:
+    - 'spec/unit/raketasks_spec.rb'

data/ChangeLog.md

@@ -1,3 +1,13 @@
+Version 0.3.0
+
+  - Add `tf:output` and `tf:output_json` Rake tasks
+  - Have TFWrapper::RakeTasks store the current terraform version as an instance variable;
+    also make this accessible as tf_version.
+  - Add '-auto-approve' to terraform apply command if running with tf >= 0.10.0
+  - Update acceptance tests to work with terraform 0.9.x and 0.10.x
+  - Acceptance test logic to find the latest terraform release version from GitHub API
+  - Run acceptance tests for multiple terraform versions (currently: 0.9.2, 0.9.7, 0.10.0, 0.10.2, latest)
+
 Version 0.2.0
 
   - initial release (migrated from previous internal/private gem)

data/README.md

@@ -45,7 +45,7 @@ gem 'tfwrapper', '~> 0.2.0'
 
 ### Supported Terraform Versions
 
-tfwrapper only supports terraform 0.9+. It has been tested up to 0.9.2.
+tfwrapper only supports terraform 0.9+. It is tested against multiple versions from 0.9.2 to 0.10.2 and the current release.
 
 ## Usage
 

data/circle.yml

@@ -20,5 +20,9 @@ test:
     - 'rvm 2.1.8 exec bundle exec rake spec:unit'
     - 'rvm 2.2.5 exec bundle exec rake spec:unit'
     - 'rvm 2.3.1 exec bundle exec rake spec:unit'
-    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance'
+    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance TF_VERSION=0.9.2'
+    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance TF_VERSION=0.9.7'
+    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance TF_VERSION=0.10.0'
+    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance TF_VERSION=0.10.2'
+    - 'rvm 2.3.1 exec bundle exec rake spec:acceptance TF_VERSION=latest'
     - 'bundle exec rake yard:generate'

data/lib/tfwrapper/raketasks.rb

@@ -31,6 +31,8 @@ module TFWrapper
       Gem::Version.new('0.9.0')
     end
 
+    attr_reader :tf_version
+
     # Generate Rake tasks for working with Terraform at Manheim.
     #
     # @param tf_dir [String] Terraform config directory, relative to Rakefile.
@@ -67,6 +69,8 @@ module TFWrapper
       @tf_extra_vars = opts.fetch(:tf_extra_vars, {})
       @backend_config = opts.fetch(:backend_config, {})
       @consul_url = opts.fetch(:consul_url, nil)
+      # default to lowest possible version; this is set in the 'init' task
+      @tf_version = Gem::Version.new('0.0.0')
       # rubocop:disable Style/GuardClause
       if @consul_url.nil? && !@consul_env_vars_prefix.nil?
         raise StandardError, 'Cannot set env vars in Consul when consul_url ' \
@@ -92,6 +96,7 @@ module TFWrapper
       install_refresh
       install_destroy
       install_write_tf_vars
+      install_output
     end
 
     # add the 'tf:init' Rake task. This checks environment variables,
@@ -102,7 +107,7 @@ module TFWrapper
         desc 'Run terraform init with appropriate arguments'
         task :init do
           TFWrapper::Helpers.check_env_vars(@tf_vars_from_env.values)
-          check_tf_version
+          @tf_version = check_tf_version
           cmd = [
             'terraform',
             'init',
@@ -146,8 +151,11 @@ module TFWrapper
           :"#{nsprefix}:write_tf_vars",
           :"#{nsprefix}:plan"
         ] do |_t, args|
+          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}"
           cmd = cmd_with_targets(
-            ['terraform', 'apply', "-var-file #{var_file_path}"],
+            cmd_arr,
             args[:target],
             args.extras
           )
@@ -176,6 +184,24 @@ module TFWrapper
       end
     end
 
+    # add the 'tf:output' Rake task
+    def install_output
+      namespace nsprefix do
+        task output: [
+          :"#{nsprefix}:init",
+          :"#{nsprefix}:refresh"
+        ] do
+          terraform_runner('terraform output')
+        end
+        task output_json: [
+          :"#{nsprefix}:init",
+          :"#{nsprefix}:refresh"
+        ] do
+          terraform_runner('terraform output -json')
+        end
+      end
+    end
+
     # add the 'tf:destroy' Rake task
     def install_destroy
       namespace nsprefix do
@@ -212,7 +238,7 @@ module TFWrapper
           tf_vars = terraform_vars
           puts 'Terraform vars:'
           tf_vars.sort.map do |k, v|
-            if k == 'aws_access_key' || k == 'aws_secret_key'
+            if %w[aws_access_key aws_secret_key].include?(k)
               puts "#{k} => (redacted)"
             else
               puts "#{k} => #{v}"
@@ -308,6 +334,7 @@ module TFWrapper
           "binary reports itself as #{m[1]} (#{all_out_err})"
       end
       puts "Running with: #{all_out_err}"
+      tf_ver
     end
 
     # update stack status in Consul
@@ -315,7 +342,7 @@ module TFWrapper
       require 'diplomat'
       require 'json'
       data = {}
-      @tf_vars_from_env.values.each { |k| data[k] = ENV[k] }
+      @tf_vars_from_env.each_value { |k| data[k] = ENV[k] }
 
       Diplomat.configure do |config|
         config.url = @consul_url

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.2.0'
+  VERSION = '0.3.0'
 end

data/spec/acceptance/acceptance_helpers.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'ffi'
+require 'faraday'
+require 'json'
 
 def cleanup_tf
   fixture_dir = File.absolute_path(
@@ -9,6 +11,20 @@ def cleanup_tf
   Dir.glob("#{fixture_dir}/**/.terraform").each do |d|
     FileUtils.rmtree(d) if File.directory?(d)
   end
+  Dir.glob("#{fixture_dir}/**/terraform.tfstate*").each do |f|
+    File.delete(f)
+  end
+end
+
+def desired_tf_version
+  if ENV.include?('TF_VERSION') && ENV['TF_VERSION'] != 'latest'
+    return ENV['TF_VERSION']
+  end
+  # else get the latest release from GitHub
+  resp = Faraday.get('https://api.github.com/repos/hashicorp/terraform/releases/latest')
+  rel = JSON.parse(resp.body)['tag_name'].sub(/^v/, '')
+  puts "Found latest terraform release on GitHub: #{rel}"
+  rel
 end
 
 class HashicorpFetcher

data/spec/acceptance/acceptance_spec.rb

@@ -5,7 +5,14 @@ require_relative 'acceptance_helpers'
 require 'open3'
 require 'json'
 
-TF_VERSION = '0.9.2'
+TF_VERSION = desired_tf_version
+if Gem::Version.new(TF_VERSION) >= Gem::Version.new('0.10.0')
+  EXPECTED_SERIAL = 2
+  APPLY_CMD = 'terraform apply -auto-approve'
+else
+  EXPECTED_SERIAL = 1
+  APPLY_CMD = 'terraform apply'
+end
 
 Diplomat.configure do |config|
   config.url = 'http://127.0.0.1:8500'
@@ -21,7 +28,7 @@ describe 'tfwrapper' do
     @server.stop
   end
   after(:each) { cleanup_tf }
-  context 'testOne - basic TF with remote state' do
+  context 'testOne - basic TF with remote state', order: :defined do
     before(:all) do
       @fixturepath = File.absolute_path(
         File.join(File.dirname(__FILE__), '..', 'fixtures')
@@ -84,7 +91,7 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testOne: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
@@ -103,7 +110,7 @@ describe 'tfwrapper' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testOne'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('bar')
@@ -112,8 +119,46 @@ describe 'tfwrapper' do
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
     end
+    describe 'tf:output' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:output 2>/dev/null',
+          chdir: @fixturepath
+        )
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to include('foo_variable = bar')
+      end
+    end
+    describe 'tf:output_json' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:output_json 2>/dev/null',
+          chdir: @fixturepath
+        )
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to match(/.*{\s+"foo_variable":\s{\s+"sensitive":\s
+                                   false,\s+"type":\s"string",\s+"value":\s
+                                   "bar"\s+}\s+}.*/x)
+      end
+    end
   end
-  context 'testTwo - TF with vars, remote state and consul env var update' do
+  context 'testTwo - TF w/ vars, rmt state & consul env var', order: :defined do
     before(:all) do
       @fixturepath = File.absolute_path(
         File.join(File.dirname(__FILE__), '..', 'fixtures', 'testTwo')
@@ -183,7 +228,7 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testTwo: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
@@ -206,7 +251,7 @@ describe 'tfwrapper' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testTwo/foo'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('fooval')
@@ -242,7 +287,7 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testTwo: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
@@ -265,7 +310,7 @@ describe 'tfwrapper' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testTwo/bar'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('fooval')
@@ -276,8 +321,29 @@ describe 'tfwrapper' do
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
     end
+    describe 'tf:output' do
+      before(:all) do
+        ENV['TFSUFFIX'] = 'bar'
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:output 2>/dev/null',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'build.tfvars.json')
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to include('foo_variable = fooval')
+        expect(@out_err).to include('bar_variable = barval')
+      end
+    end
   end
-  context 'testThree - TF with namespaces' do
+  context 'testThree - TF with namespaces', order: :defined do
     before(:all) do
       @fixturepath = File.absolute_path(
         File.join(File.dirname(__FILE__), '..', 'fixtures', 'testThree')
@@ -372,40 +438,63 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testThreeFoo: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
         )
         expect(@out_err).to include(
-          "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
+          "Outputs:\n\nbar_variable = barONEval\nfoo_variable = fooval"
         )
       end
       it 'writes the vars file' do
         expect(File.file?(@varpath)).to be(true)
         c = File.open(@varpath, 'r').read
         expect(JSON.parse(c))
-          .to eq('foo' => 'fooval', 'bar' => 'barval')
+          .to eq('foo' => 'fooval', 'bar' => 'barONEval')
       end
       it 'sets the consul keys' do
         expect(Diplomat::Kv.get('testThreeFoo/foo')).to eq('fooval')
-        expect(Diplomat::Kv.get('testThreeFoo/bar')).to eq('barval')
+        expect(Diplomat::Kv.get('testThreeFoo/bar')).to eq('barONEval')
       end
       it 'writes remote state to consul' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testThreeFoo'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('fooval')
         expect(state['modules'][0]['outputs']['bar_variable']['value'])
-          .to eq('barval')
+          .to eq('barONEval')
         expect(state['modules'][0]['resources'])
           .to include('consul_keys.testThreeFoo')
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
     end
+    describe 'tf:output' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake tf:output 2>/dev/null',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to include('foo_variable = fooval')
+        expect(@out_err).to include('bar_variable = barONEval')
+      end
+    end
     describe 'bar_tf:apply' do
       before(:all) do
         @out_err, @ecode = Open3.capture2e(
@@ -429,40 +518,63 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testThreeBar: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
         )
         expect(@out_err).to include(
-          "Outputs:\n\nbar_variable = barval\nfoo_variable = fooval"
+          "Outputs:\n\nbar_variable = barTWOval\nfoo_variable = fooval"
         )
       end
       it 'writes the vars file' do
         expect(File.file?(@varpath)).to be(true)
         c = File.open(@varpath, 'r').read
         expect(JSON.parse(c))
-          .to eq('foo' => 'fooval', 'bar' => 'barval')
+          .to eq('foo' => 'fooval', 'bar' => 'barTWOval')
       end
       it 'sets the consul keys' do
         expect(Diplomat::Kv.get('testThreeBar/foo')).to eq('fooval')
-        expect(Diplomat::Kv.get('testThreeBar/bar')).to eq('barval')
+        expect(Diplomat::Kv.get('testThreeBar/bar')).to eq('barTWOval')
       end
       it 'writes remote state to consul' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testThreeBar'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('fooval')
         expect(state['modules'][0]['outputs']['bar_variable']['value'])
-          .to eq('barval')
+          .to eq('barTWOval')
         expect(state['modules'][0]['resources'])
           .to include('consul_keys.testThreeBar')
         expect(state['modules'][0]['resources'].length).to eq(1)
       end
     end
+    describe 'bar_tf:output' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake bar_tf:output 2>/dev/null',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'bar_build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to include('foo_variable = fooval')
+        expect(@out_err).to include('bar_variable = barTWOval')
+      end
+    end
     describe 'baz_tf:apply' do
       before(:all) do
         @out_err, @ecode = Open3.capture2e(
@@ -486,7 +598,7 @@ describe 'tfwrapper' do
       end
       it 'runs apply correctly and succeeds' do
         expect(@out_err)
-          .to include('terraform_runner command: \'terraform apply -var-file')
+          .to include("terraform_runner command: '#{APPLY_CMD} -var-file")
         expect(@out_err).to include('consul_keys.testThreeBaz: Creating...')
         expect(@out_err).to include(
           'Apply complete! Resources: 1 added, 0 changed, 0 destroyed.'
@@ -508,7 +620,7 @@ describe 'tfwrapper' do
         state = JSON.parse(Diplomat::Kv.get('terraform/testThreeBaz'))
         expect(state['version']).to eq(3)
         expect(state['terraform_version']).to eq(TF_VERSION)
-        expect(state['serial']).to eq(1)
+        expect(state['serial']).to eq(EXPECTED_SERIAL)
         expect(state['modules'].length).to eq(1)
         expect(state['modules'][0]['outputs']['foo_variable']['value'])
           .to eq('fooval')
@@ -521,5 +633,28 @@ describe 'tfwrapper' do
         expect(cvars).to eq('FOO' => 'fooval')
       end
     end
+    describe 'baz_tf:output' do
+      before(:all) do
+        @out_err, @ecode = Open3.capture2e(
+          'timeout -k 60 45 bundle exec rake baz_tf:output 2>/dev/null',
+          chdir: @fixturepath
+        )
+        @varpath = File.join(@fixturepath, 'baz_build.tfvars.json')
+      end
+      after(:all) do
+        File.delete(@varpath) if File.file?(@varpath)
+      end
+      it 'does not time out' do
+        expect(@ecode.exitstatus).to_not eq(124)
+        expect(@ecode.exitstatus).to_not eq(137)
+      end
+      it 'exits zero' do
+        expect(@ecode.exitstatus).to eq(0)
+      end
+      it 'shows the outputs' do
+        expect(@out_err).to include('foo_variable = fooval')
+        expect(@out_err).to_not include('bar_variable = ')
+      end
+    end
   end
 end

data/spec/fixtures/testThree/Rakefile

@@ -13,14 +13,14 @@ TFWrapper::RakeTasks.install_tasks(
   'foo',
   backend_config: { 'path' => 'terraform/testThreeFoo' },
   tf_vars_from_env: { 'foo' => 'FOO' },
-  tf_extra_vars: { 'bar' => 'barval' }
+  tf_extra_vars: { 'bar' => 'barONEval' }
 )
 
 TFWrapper::RakeTasks.install_tasks(
   'bar',
   namespace_prefix: 'bar',
   tf_vars_from_env: { 'foo' => 'FOO' },
-  tf_extra_vars: { 'bar' => 'barval' }
+  tf_extra_vars: { 'bar' => 'barTWOval' }
 )
 
 TFWrapper::RakeTasks.install_tasks(

data/spec/unit/raketasks_spec.rb

@@ -60,6 +60,8 @@ describe TFWrapper::RakeTasks do
       expect(cls.instance_variable_get('@tf_extra_vars')).to eq({})
       expect(cls.instance_variable_get('@backend_config')).to eq({})
       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'))
     end
     it 'sets options' do
       allow(ENV).to receive(:[])
@@ -212,12 +214,14 @@ describe TFWrapper::RakeTasks do
       allow(subject).to receive(:install_refresh)
       allow(subject).to receive(:install_destroy)
       allow(subject).to receive(:install_write_tf_vars)
+      allow(subject).to receive(:install_output)
       expect(subject).to receive(:install_init).once
       expect(subject).to receive(:install_plan).once
       expect(subject).to receive(:install_apply).once
       expect(subject).to receive(:install_refresh).once
       expect(subject).to receive(:install_destroy).once
       expect(subject).to receive(:install_write_tf_vars).once
+      expect(subject).to receive(:install_output).once
       subject.install
     end
   end
@@ -240,6 +244,8 @@ describe TFWrapper::RakeTasks do
     end
     it 'runs the init command with backend_config options' do
       Rake.application['tf:init'].clear_prerequisites
+      expect(subject.instance_variable_get(:@tf_version))
+        .to eq(Gem::Version.new('0.0.0'))
       vars = { foo: 'bar', baz: 'blam' }
       subject.instance_variable_set('@tf_vars_from_env', vars)
       allow(TFWrapper::Helpers).to receive(:check_env_vars)
@@ -252,6 +258,7 @@ describe TFWrapper::RakeTasks do
       )
       allow(subject).to receive(:terraform_runner)
       allow(subject).to receive(:check_tf_version)
+        .and_return(Gem::Version.new('0.9.5'))
       expect(TFWrapper::Helpers)
         .to receive(:check_env_vars).once.ordered.with(vars.values)
       expect(subject).to receive(:check_tf_version).once.ordered
@@ -261,6 +268,8 @@ describe TFWrapper::RakeTasks do
         ' -backend-config=\'path=consulprefix\''\
         ' -backend-config=\'foo=bar\'')
       Rake.application['tf:init'].invoke
+      expect(subject.instance_variable_get(:@tf_version))
+        .to eq(Gem::Version.new('0.9.5'))
     end
     it 'runs the init command without backend_config options' do
       Rake.application['tf:init'].clear_prerequisites
@@ -271,12 +280,15 @@ describe TFWrapper::RakeTasks do
       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'))
       expect(TFWrapper::Helpers)
         .to receive(:check_env_vars).once.ordered.with(vars.values)
       expect(subject).to receive(:check_tf_version).once.ordered
       expect(subject).to receive(:terraform_runner).once.ordered
         .with('terraform init -input=false')
       Rake.application['tf:init'].invoke
+      expect(subject.instance_variable_get(:@tf_version))
+        .to eq(Gem::Version.new('0.10.2'))
     end
   end
   describe '#install_plan' do
@@ -341,53 +353,105 @@ describe TFWrapper::RakeTasks do
     before do
       subject.install_apply
     end
-
     it 'adds the apply task' do
       expect(Rake.application['tf:apply']).to be_instance_of(Rake::Task)
       expect(Rake.application['tf:apply'].prerequisites)
         .to eq(%w[tf:init tf:write_tf_vars tf:plan])
       expect(Rake.application['tf:apply'].arg_names).to eq([:target])
     end
-    it 'runs the apply command with no targets' 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)
-      expect(subject).to receive(:terraform_runner).once
-        .with('terraform apply -var-file file.tfvars.json')
-      expect(subject).to_not receive(:update_consul_stack_env_vars)
-      Rake.application['tf:apply'].invoke
-    end
-    it 'runs the apply command with one target' 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)
-      expect(subject).to receive(:terraform_runner).once
-        .with('terraform apply -var-file file.tfvars.json ' \
-              '-target tar.get[1]')
-      Rake.application['tf:apply'].invoke('tar.get[1]')
-    end
-    it 'runs the apply command with three targets' 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)
-      expect(subject).to receive(:terraform_runner).once
-        .with('terraform apply -var-file file.tfvars.json ' \
-              '-target tar.get[1] -target t.gt[2] -target my.target[3]')
-      Rake.application['tf:apply'].invoke(
-        'tar.get[1]', 't.gt[2]', 'my.target[3]'
-      )
+    context 'terraform version 0.9.5' do
+      before(:each) do
+        allow(subject).to receive(:tf_version)
+          .and_return(Gem::Version.new('0.9.5'))
+      end
+      it 'runs the apply command with no targets' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -var-file file.tfvars.json')
+        expect(subject).to_not receive(:update_consul_stack_env_vars)
+        Rake.application['tf:apply'].invoke
+      end
+      it 'runs the apply command with one target' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -var-file file.tfvars.json ' \
+                '-target tar.get[1]')
+        Rake.application['tf:apply'].invoke('tar.get[1]')
+      end
+      it 'runs the apply command with three targets' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -var-file file.tfvars.json ' \
+                '-target tar.get[1] -target t.gt[2] -target my.target[3]')
+        Rake.application['tf:apply'].invoke(
+          'tar.get[1]', 't.gt[2]', 'my.target[3]'
+        )
+      end
+      it 'runs update_consul_stack_env_vars if consul_env_vars_prefix !nil' do
+        subject.instance_variable_set('@consul_env_vars_prefix', 'foo')
+        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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -var-file file.tfvars.json')
+        expect(subject).to receive(:update_consul_stack_env_vars).once
+        Rake.application['tf:apply'].invoke
+      end
     end
-    it 'runs update_consul_stack_env_vars if consul_env_vars_prefix not nil' do
-      subject.instance_variable_set('@consul_env_vars_prefix', 'foo')
-      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)
-      expect(subject).to receive(:terraform_runner).once
-        .with('terraform apply -var-file file.tfvars.json')
-      expect(subject).to receive(:update_consul_stack_env_vars).once
-      Rake.application['tf:apply'].invoke
+    context 'terraform version 0.10.2' do
+      before(:each) do
+        allow(subject).to receive(:tf_version)
+          .and_return(Gem::Version.new('0.10.2'))
+      end
+      it 'runs the apply command with no targets' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -auto-approve -var-file file.tfvars.json')
+        expect(subject).to_not receive(:update_consul_stack_env_vars)
+        Rake.application['tf:apply'].invoke
+      end
+      it 'runs the apply command with one target' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -auto-approve -var-file file.tfvars.json ' \
+                '-target tar.get[1]')
+        Rake.application['tf:apply'].invoke('tar.get[1]')
+      end
+      it 'runs the apply command with three targets' 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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -auto-approve -var-file file.tfvars.json ' \
+                '-target tar.get[1] -target t.gt[2] -target my.target[3]')
+        Rake.application['tf:apply'].invoke(
+          'tar.get[1]', 't.gt[2]', 'my.target[3]'
+        )
+      end
+      it 'runs update_consul_stack_env_vars if consul_env_vars_prefix !nil' do
+        subject.instance_variable_set('@consul_env_vars_prefix', 'foo')
+        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)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform apply -auto-approve -var-file file.tfvars.json')
+        expect(subject).to receive(:update_consul_stack_env_vars).once
+        Rake.application['tf:apply'].invoke
+      end
     end
   end
   describe '#install_refresh' do
@@ -558,6 +622,47 @@ describe TFWrapper::RakeTasks do
       end
     end
   end
+  describe '#install_output' do
+    # these let/before/after come from bundler's gem_helper_spec.rb
+    let!(:rake_application) { Rake.application }
+    before(:each) do
+      Rake::Task.clear
+      Rake.application = Rake::Application.new
+    end
+    after(:each) do
+      Rake.application = rake_application
+    end
+    before do
+      subject.install_output
+    end
+
+    it 'adds the output task' do
+      expect(Rake.application['tf:output']).to be_instance_of(Rake::Task)
+      expect(Rake.application['tf:output'].prerequisites)
+        .to eq(%w[tf:init tf:refresh])
+    end
+    it 'runs the output command' 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)
+      expect(subject).to receive(:terraform_runner).once
+        .with('terraform output')
+      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)
+        .to eq(%w[tf:init tf:refresh])
+    end
+    it 'runs the output -json command' 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)
+      expect(subject).to receive(:terraform_runner).once
+        .with('terraform output -json')
+      Rake.application['tf:output_json'].invoke
+    end
+  end
   describe '#terraform_vars' do
     it 'builds a hash and sets overrides' do
       v_from_e = { 'vfe1' => 'vfe1name', 'vfe2' => 'vfe2name' }
@@ -718,7 +823,7 @@ describe TFWrapper::RakeTasks do
         .and_return(['Terraform v3.4.5-dev (abcde1234+CHANGES)', 0])
       allow(Gem::Version).to receive(:new).and_return(ver)
       expect(Gem::Version).to receive(:new).once.with('3.4.5')
-      subject.check_tf_version
+      expect(subject.check_tf_version).to eq(ver)
     end
     it 'fails if the version cannot be identified' do
       allow(TFWrapper::Helpers).to receive(:run_cmd_stream_output)

data/tfwrapper.gemspec

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 
 require File.expand_path('../lib/tfwrapper/version', __FILE__)

metadata

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