tfwrapper 0.4.1 → 0.6.2

data/spec/unit/raketasks_spec.rb

@@ -59,6 +59,8 @@ describe TFWrapper::RakeTasks do
       expect(cls.instance_variable_get('@tf_dir')).to eq('/rake/dir/tfdir')
       expect(cls.instance_variable_get('@consul_env_vars_prefix')).to eq(nil)
       expect(cls.instance_variable_get('@tf_vars_from_env')).to eq({})
+      expect(cls.instance_variable_get('@allowed_empty_vars')).to eq([])
+      expect(cls.instance_variable_get('@tf_sensitive_vars')).to eq([])
       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)
@@ -66,6 +68,8 @@ describe TFWrapper::RakeTasks do
         .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)
+      expect(cls.instance_variable_get('@disable_landscape')).to eq(false)
+      expect(cls.instance_variable_get('@landscape_progress')).to eq(nil)
     end
     it 'sets options' do
       allow(ENV).to receive(:[])
@@ -85,10 +89,14 @@ describe TFWrapper::RakeTasks do
         'tf/dir',
         consul_env_vars_prefix: 'cvprefix',
         tf_vars_from_env: { 'foo' => 'bar' },
+        allowed_empty_vars: %w[bar blam],
+        tf_sensitive_vars: %w[secret],
         tf_extra_vars: { 'baz' => 'blam' },
         consul_url: 'foobar',
         before_proc: bproc,
-        after_proc: aproc
+        after_proc: aproc,
+        disable_landscape: true,
+        landscape_progress: :dots
       )
       expect(cls.instance_variable_get('@tf_dir'))
         .to eq('/path/to/tf/dir')
@@ -96,12 +104,18 @@ describe TFWrapper::RakeTasks do
         .to eq('cvprefix')
       expect(cls.instance_variable_get('@tf_vars_from_env'))
         .to eq('foo' => 'bar')
+      expect(cls.instance_variable_get('@allowed_empty_vars'))
+        .to eq(%w[bar blam])
+      expect(cls.instance_variable_get('@tf_sensitive_vars'))
+        .to eq(%w[secret])
       expect(cls.instance_variable_get('@tf_extra_vars'))
         .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)
+      expect(cls.instance_variable_get('@disable_landscape')).to eq(true)
+      expect(cls.instance_variable_get('@landscape_progress')).to eq(:dots)
     end
     context 'when before_proc is not a proc or nil' do
       it 'raises an error' do
@@ -120,6 +134,23 @@ describe TFWrapper::RakeTasks do
           )
       end
     end
+    context 'when landscape_progress is an invalid value' 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', landscape_progress: :foo) }
+          .to raise_error(
+            ArgumentError,
+            /landscape_progress option must be one of:/
+          )
+      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)
@@ -294,6 +325,7 @@ describe TFWrapper::RakeTasks do
         .to eq(Gem::Version.new('0.0.0'))
       vars = { foo: 'bar', baz: 'blam' }
       subject.instance_variable_set('@tf_vars_from_env', vars)
+      subject.instance_variable_set('@allowed_empty_vars', ['bar'])
       allow(TFWrapper::Helpers).to receive(:check_env_vars)
       allow(ENV).to receive(:[])
       subject.instance_variable_set(
@@ -306,7 +338,7 @@ describe TFWrapper::RakeTasks do
       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)
+        .to receive(:check_env_vars).once.ordered.with(vars.values, ['bar'])
       expect(subject).to receive(:check_tf_version).once.ordered
       expect(subject).to receive(:terraform_runner).once.ordered
         .with('terraform init -input=false '\
@@ -328,7 +360,7 @@ describe TFWrapper::RakeTasks do
       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)
+        .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')
@@ -377,6 +409,7 @@ describe TFWrapper::RakeTasks do
     before(:each) do
       Rake::Task.clear
       Rake.application = Rake::Application.new
+      allow(subject).to receive(:landscape_format)
     end
     after(:each) do
       Rake.application = rake_application
@@ -392,33 +425,107 @@ describe TFWrapper::RakeTasks do
       expect(Rake.application['tf:plan'].arg_names).to eq([:target])
     end
     it 'runs the plan command with no targets' do
+      stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', true)
       Rake.application['tf:plan'].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 plan -var-file file.tfvars.json')
+        .with('terraform plan -var-file file.tfvars.json', progress: nil)
       Rake.application['tf:plan'].invoke
     end
     it 'runs the plan command with one target' do
+      stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', true)
       Rake.application['tf:plan'].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 plan -var-file file.tfvars.json ' \
-              '-target tar.get[1]')
+              '-target tar.get[1]', progress: nil)
       Rake.application['tf:plan'].invoke('tar.get[1]')
     end
     it 'runs the plan command with three targets' do
+      stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', true)
       Rake.application['tf:plan'].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 plan -var-file file.tfvars.json ' \
-              '-target tar.get[1] -target t.gt[2] -target my.target[3]')
+              '-target tar.get[1] -target t.gt[2] -target my.target[3]',
+              progress: nil)
       Rake.application['tf:plan'].invoke(
         'tar.get[1]', 't.gt[2]', 'my.target[3]'
       )
     end
+    context 'with terraform_landscape available and enabled' do
+      before(:each) do
+        stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', true)
+        allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+        allow(subject).to receive(:terraform_runner).and_return('TFoutput')
+      end
+      it 'runs plan with default progress type' do
+        Rake.application['tf:plan'].clear_prerequisites
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform plan -var-file file.tfvars.json', progress: nil)
+        expect(subject).to receive(:landscape_format).once.with('TFoutput')
+        Rake.application['tf:plan'].invoke
+      end
+      it 'runs plan with dots progress type' do
+        Rake.application['tf:plan'].clear_prerequisites
+        subject.instance_variable_set('@landscape_progress', :dots)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform plan -var-file file.tfvars.json', progress: :dots)
+        expect(subject).to receive(:landscape_format).once.with('TFoutput')
+        Rake.application['tf:plan'].invoke
+      end
+      it 'runs plan with lines progress type' do
+        Rake.application['tf:plan'].clear_prerequisites
+        subject.instance_variable_set('@landscape_progress', :lines)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform plan -var-file file.tfvars.json', progress: :lines)
+        expect(subject).to receive(:landscape_format).once.with('TFoutput')
+        Rake.application['tf:plan'].invoke
+      end
+      it 'runs plan with stream progress type' do
+        Rake.application['tf:plan'].clear_prerequisites
+        subject.instance_variable_set('@landscape_progress', :stream)
+        expect(subject).to receive(:terraform_runner).once
+          .with('terraform plan -var-file file.tfvars.json',
+                progress: :stream)
+        expect(subject).to receive(:landscape_format).once.with('TFoutput')
+        Rake.application['tf:plan'].invoke
+      end
+    end
+    context 'with terraform_landscape unavailable' do
+      it 'runs plan with stream progress and does not run landscape' do
+        stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', false)
+        allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+        allow(subject).to receive(:terraform_runner).and_return('TFoutput')
+
+        Rake.application['tf:plan'].clear_prerequisites
+        expect(subject).to receive(:terraform_runner).once
+          .with(
+            'terraform plan -var-file file.tfvars.json', progress: :stream
+          )
+        expect(subject).to_not receive(:landscape_format)
+        Rake.application['tf:plan'].invoke
+      end
+    end
+    context 'with terraform_landscape available but disabled' do
+      it 'runs plan with stream progress and does not run landscape' do
+        stub_const('TFWrapper::RakeTasks::HAVE_LANDSCAPE', true)
+        allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
+        allow(subject).to receive(:terraform_runner).and_return('TFoutput')
+
+        subject.instance_variable_set('@disable_landscape', true)
+        Rake.application['tf:plan'].clear_prerequisites
+        expect(subject).to receive(:terraform_runner).once
+          .with(
+            'terraform plan -var-file file.tfvars.json', progress: :stream
+          )
+        expect(subject).to_not receive(:landscape_format)
+        Rake.application['tf:plan'].invoke
+      end
+    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')
@@ -729,6 +836,7 @@ describe TFWrapper::RakeTasks do
         Rake.application = rake_application
       end
       before do
+        subject.instance_variable_set('@tf_sensitive_vars', ['secret'])
         subject.install_write_tf_vars
       end
 
@@ -741,7 +849,8 @@ describe TFWrapper::RakeTasks do
         vars = {
           'foo' => 'bar',
           'baz' => 'blam',
-          'aws_access_key' => 'ak'
+          'aws_access_key' => 'ak',
+          'secret' => 'abc'
         }
         allow(subject).to receive(:terraform_vars).and_return(vars)
         allow(subject).to receive(:var_file_path).and_return('file.tfvars.json')
@@ -753,6 +862,8 @@ describe TFWrapper::RakeTasks do
         expect(STDOUT).to receive(:puts).once.with('Terraform vars:')
         expect(STDOUT).to receive(:puts)
           .once.with('aws_access_key => (redacted)')
+        expect(STDOUT).to receive(:puts)
+          .once.with('secret => (redacted)')
         expect(STDOUT).to receive(:puts).once.with('baz => blam')
         expect(STDOUT).to receive(:puts).once.with('foo => bar')
         expect(File).to receive(:open).once.with('file.tfvars.json', 'w')
@@ -814,6 +925,7 @@ describe TFWrapper::RakeTasks do
         Rake.application = rake_application
       end
       before do
+        subject.instance_variable_set('@tf_sensitive_vars', ['secret'])
         subject.instance_variable_set('@ns_prefix', 'foo')
         subject.install_write_tf_vars
       end
@@ -827,7 +939,8 @@ describe TFWrapper::RakeTasks do
         vars = {
           'foo' => 'bar',
           'baz' => 'blam',
-          'aws_access_key' => 'ak'
+          'aws_access_key' => 'ak',
+          'secret' => 'abc'
         }
         allow(subject).to receive(:terraform_vars).and_return(vars)
         allow(subject).to receive(:var_file_path)
@@ -840,6 +953,8 @@ describe TFWrapper::RakeTasks do
         expect(STDOUT).to receive(:puts).once.with('Terraform vars:')
         expect(STDOUT).to receive(:puts)
           .once.with('aws_access_key => (redacted)')
+        expect(STDOUT).to receive(:puts)
+          .once.with('secret => (redacted)')
         expect(STDOUT).to receive(:puts).once.with('baz => blam')
         expect(STDOUT).to receive(:puts).once.with('foo => bar')
         expect(File).to receive(:open).once.with('foo_file.tfvars.json', 'w')
@@ -1003,20 +1118,102 @@ describe TFWrapper::RakeTasks do
       )
     end
   end
+  describe '#landscape_format', if: HAVE_LANDSCAPE do
+    before(:each) do
+      allow(STDERR).to receive(:puts)
+      allow(STDOUT).to receive(:puts)
+    end
+    context 'when no exception is raised' do
+      it 'processes the string through TerraformLandscape' do
+        dbl_printer = double
+        dbl_output = double
+        allow(TerraformLandscape::Printer)
+          .to receive(:new).and_return(dbl_printer)
+        allow(TerraformLandscape::Output)
+          .to receive(:new).and_return(dbl_output)
+        allow(dbl_printer).to receive(:process_string)
+
+        expect(TerraformLandscape::Output)
+          .to receive(:new).once.with(STDOUT)
+        expect(TerraformLandscape::Printer)
+          .to receive(:new).once.with(dbl_output)
+        expect(dbl_printer).to receive(:process_string).once.with('PlanOutput')
+        expect(STDERR).to_not receive(:puts)
+        expect(STDOUT).to_not receive(:puts)
+        subject.landscape_format('PlanOutput')
+      end
+    end
+    context 'when an exception is raised' do
+      context 'and landscape_progress is :stream' do
+        it 'prints an error message' do
+          dbl_printer = double
+          dbl_output = double
+          allow(TerraformLandscape::Printer)
+            .to receive(:new).and_return(dbl_printer)
+          allow(TerraformLandscape::Output)
+            .to receive(:new).and_return(dbl_output)
+          allow(dbl_printer).to receive(:process_string)
+            .and_raise(RuntimeError, 'FooError')
+
+          expect(TerraformLandscape::Output)
+            .to receive(:new).once.with(STDOUT)
+          expect(TerraformLandscape::Printer)
+            .to receive(:new).once.with(dbl_output)
+          expect(dbl_printer)
+            .to receive(:process_string).once.with('PlanOutput')
+          expect(STDERR).to receive(:puts).once
+            .with(
+              'Exception calling terraform_landscape to reformat output: ' \
+              'RuntimeError: FooError'
+            )
+          expect(STDOUT).to_not receive(:puts)
+          subject.instance_variable_set('@landscape_progress', :stream)
+          subject.landscape_format('PlanOutput')
+        end
+      end
+      context 'and landscape_progress is not :stream' do
+        it 'prints an error message and then the output' do
+          dbl_printer = double
+          dbl_output = double
+          allow(TerraformLandscape::Printer)
+            .to receive(:new).and_return(dbl_printer)
+          allow(TerraformLandscape::Output)
+            .to receive(:new).and_return(dbl_output)
+          allow(dbl_printer).to receive(:process_string)
+            .and_raise(RuntimeError, 'FooError')
+
+          expect(TerraformLandscape::Output)
+            .to receive(:new).once.with(STDOUT)
+          expect(TerraformLandscape::Printer)
+            .to receive(:new).once.with(dbl_output)
+          expect(dbl_printer)
+            .to receive(:process_string).once.with('PlanOutput')
+          expect(STDERR).to receive(:puts).once
+            .with(
+              'Exception calling terraform_landscape to reformat output: ' \
+              'RuntimeError: FooError'
+            )
+          expect(STDOUT).to receive(:puts).once.with('PlanOutput')
+          subject.instance_variable_set('@landscape_progress', nil)
+          subject.landscape_format('PlanOutput')
+        end
+      end
+    end
+  end
   describe '#terraform_runner' do
     before do
       Retries.sleep_enabled = false
     end
     it 'outputs nothing and succeeds when command succeeds' do
       allow(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .with(any_args).and_return(['', 0])
+        .with(any_args).and_return(['MyOutput', 0])
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .once.with('foo', 'tfdir')
+        .once.with('foo', 'tfdir', progress: :stream)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command: 'foo' (in tfdir)")
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command 'foo' finished and exited 0")
-      subject.terraform_runner('foo')
+      expect(subject.terraform_runner('foo')).to eq('MyOutput')
     end
     it 'retries if needed' do
       @times_called = 0
@@ -1027,7 +1224,7 @@ describe TFWrapper::RakeTasks do
       end
 
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .exactly(2).times.with('foo', 'tfdir')
+        .exactly(2).times.with('foo', 'tfdir', progress: :stream)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command: 'foo' (in tfdir)")
       expect(STDERR).to receive(:puts).once
@@ -1044,23 +1241,25 @@ describe TFWrapper::RakeTasks do
         if @times_called < 3
           ['foo Throttling bar', 2]
         else
-          ['', 0]
+          ['out', 0]
         end
       end
 
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .exactly(3).times.with('foo', 'tfdir')
+        .exactly(3).times.with('foo', 'tfdir', progress: :stream)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command: 'foo' (in tfdir)")
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\shit\sAWS\sAPI\srate\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sThrottling\sbar\s+
+          Terraform\shit\sAWS\sAPI\srate\s
           limiting;\sretry\sattempt\s1;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\shit\sAWS\sAPI\srate\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sThrottling\sbar\s+
+          Terraform\shit\sAWS\sAPI\srate\s
           limiting;\sretry\sattempt\s2;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command 'foo' finished and exited 0")
-      subject.terraform_runner('foo')
+      expect(subject.terraform_runner('foo')).to eq('out')
     end
     it 'retries if status code 403' do
       @times_called = 0
@@ -1074,20 +1273,22 @@ describe TFWrapper::RakeTasks do
       end
 
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .exactly(3).times.with('foo', 'tfdir')
+        .exactly(3).times.with('foo', 'tfdir', progress: :dots)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command: 'foo' (in tfdir)")
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\scommand\sgot\s403\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sstatus\scode:\s403\sbar\s+
+          Terraform\scommand\sgot\s403\s
         error\s-\saccess\sdenied\sor\scredentials\snot\spropagated;\sretry\s
         attempt\s1;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\scommand\sgot\s403\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sstatus\scode:\s403\sbar\s+
+          Terraform\scommand\sgot\s403\s
         error\s-\saccess\sdenied\sor\scredentials\snot\spropagated;\sretry\s
         attempt\s2;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command 'foo' finished and exited 0")
-      subject.terraform_runner('foo')
+      subject.terraform_runner('foo', progress: :dots)
     end
     it 'retries if status code 401' do
       @times_called = 0
@@ -1101,31 +1302,54 @@ describe TFWrapper::RakeTasks do
       end
 
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
-        .exactly(3).times.with('foo', 'tfdir')
+        .exactly(3).times.with('foo', 'tfdir', progress: nil)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command: 'foo' (in tfdir)")
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\scommand\sgot\s401\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sstatus\scode:\s401\sbar\s+
+        Terraform\scommand\sgot\s401\s
         error\s-\saccess\sdenied\sor\scredentials\snot\spropagated;\sretry\s
         attempt\s1;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
-        .with(/terraform_runner\sfailed\swith\sTerraform\scommand\sgot\s401\s
+        .with(/terraform_runner\sfailed\swith\sfoo\sstatus\scode:\s401\sbar\s+
+        Terraform\scommand\sgot\s401\s
         error\s-\saccess\sdenied\sor\scredentials\snot\spropagated;\sretry\s
         attempt\s2;\s.+\sseconds\shave\spassed\./x)
       expect(STDERR).to receive(:puts).once
         .with("terraform_runner command 'foo' finished and exited 0")
-      subject.terraform_runner('foo')
+      subject.terraform_runner('foo', progress: nil)
     end
     it 'raises an error if the command exits non-zero' do
       allow(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
         .and_return(['', 1])
       expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output).once
-        .with('foo', 'tfdir')
+        .with('foo', 'tfdir', progress: :stream)
       expect(STDERR).to receive(:puts).once
         .with('terraform_runner command: \'foo\' (in tfdir)')
       expect { subject.terraform_runner('foo') }
         .to raise_error('Errors have occurred executing: \'foo\' (exited 1)')
     end
+    it 'prints output to STDERR if plan exits non-zero and not :stream' do
+      allow(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
+        .and_return(['myoutput', 1])
+      expect(TFWrapper::Helpers).to receive(:run_cmd_stream_output).once
+        .with('foo', 'tfdir', progress: :dots)
+      expect(STDERR).to receive(:puts).once
+        .with('terraform_runner command: \'foo\' (in tfdir)')
+      expect(STDERR).to receive(:puts).once
+        .with('myoutput')
+      expect { subject.terraform_runner('foo', progress: :dots) }
+        .to raise_error('Errors have occurred executing: \'foo\' (exited 1)')
+    end
+    it 'raises an error if the progress option is invalid' do
+      allow(TFWrapper::Helpers).to receive(:run_cmd_stream_output)
+        .and_return(['', 1])
+      expect(TFWrapper::Helpers).to_not receive(:run_cmd_stream_output)
+      expect { subject.terraform_runner('foo', progress: :foo) }
+        .to raise_error(
+          'progress option must be one of: [:dots, :lines, :stream, nil]'
+        )
+    end
   end
   describe '#check_tf_version' do
     it 'fails if the command exits non-zero' do