rspec-bash 0.1.1 → 0.2.0

data/spec/integration/stubbed_command/returns_exitstatus_spec.rb

@@ -1,98 +1,107 @@
 require 'spec_helper'
+include Rspec::Bash
+
+def execute_script(script)
+  let!(:execute_results) do
+    stdout, stderr, status = stubbed_env.execute_inline(
+      script
+    )
+    [stdout, stderr, status]
+  end
+  let(:stdout) { execute_results[0] }
+  let(:stderr) { execute_results[1] }
+  let(:exitcode) { execute_results[2].exitstatus }
+end
 
 describe 'StubbedCommand' do
-  include Rspec::Bash
   let(:stubbed_env) { create_stubbed_env }
-  let!(:command1_stub) { stubbed_env.stub_command('command1') }
+  let!(:command) { stubbed_env.stub_command('stubbed_command') }
 
   context '#returns_exitstatus' do
     context 'when given no exit status to return' do
-      let(:status) do
-        _, _, status = stubbed_env.execute_inline('command1 first_argument second_argument')
-        status.exitstatus
-      end
+      execute_script('stubbed_command first_argument second_argument')
 
       it 'exits with the appropriate exit code' do
-        expect(status).to be 0
+        expect(exitcode).to be 0
       end
     end
 
     context 'when given no args to match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .returns_exitstatus(100)
-        _, _, status = stubbed_env.execute_inline('command1 first_argument second_argument')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command first_argument second_argument')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 100
+        expect(exitcode).to be 100
       end
     end
 
     context 'when given an exact argument match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .with_args('first_argument', 'second_argument')
           .returns_exitstatus(101)
-        _, _, status = stubbed_env.execute_inline('command1 first_argument second_argument')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command first_argument second_argument')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 101
+        expect(exitcode).to be 101
       end
     end
     context 'when given an anything argument match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .with_args('first_argument', anything)
           .returns_exitstatus(102)
-        _, _, status = stubbed_env.execute_inline('command1 first_argument second_argument')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command first_argument second_argument')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 102
+        expect(exitcode).to be 102
       end
     end
     context 'when given any_args argument match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .with_args(any_args)
           .returns_exitstatus(103)
-        _, _, status = stubbed_env.execute_inline('command1 poglet piglet')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command poglet piglet')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 103
+        expect(exitcode).to be 103
       end
     end
     context 'when given other types of RSpec::Mock::ArgumentMatcher argument match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .with_args(instance_of(String), instance_of(String))
           .returns_exitstatus(104)
-        _, _, status = stubbed_env.execute_inline('command1 poglet 1')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command poglet 1')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 104
+        expect(exitcode).to be 104
       end
     end
     context 'when given regex argument match' do
-      let(:status) do
-        command1_stub
+      before do
+        command
           .with_args(/p.glet/, /p.glet/)
           .returns_exitstatus(105)
-        _, _, status = stubbed_env.execute_inline('command1 poglet piglet')
-        status.exitstatus
       end
 
+      execute_script('stubbed_command poglet piglet')
+
       it 'exits with the appropriate exit code' do
-        expect(status).to be 105
+        expect(exitcode).to be 105
       end
     end
   end

data/spec/integration/stubbed_env/execute_with_env_vars_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
+include Rspec::Bash
 
 describe 'StubbedEnv' do
-  include Rspec::Bash
+  subject { create_stubbed_env }
 
   context '#execute(..., ENV => VARIABLES)' do
-    let(:stubbed_env) { create_stubbed_env }
-
     it 'exits with an error' do
-      stdout, = stubbed_env.execute_inline(
+      stdout, = subject.execute_inline(
         'echo $SOME_ENV_VAR',
         'SOME_ENV_VAR' => 'SekretCredential'
       )

data/spec/integration/stubbed_env/execute_with_path_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
+include Rspec::Bash
 
 describe 'StubbedEnv' do
-  include Rspec::Bash
+  subject { create_stubbed_env }
 
   context '#execute(path, ...)' do
     describe 'running a file with non-existing commands' do
@@ -11,21 +12,19 @@ describe 'StubbedEnv' do
       end
 
       context 'with stubbed environment' do
-        let(:stubbed_env) { create_stubbed_env }
-
         it 'exits with an error' do
-          stubbed_env.execute_inline 'command1 "foo bar" 2>&1'
+          subject.execute_inline 'command1 "foo bar" 2>&1'
           expect($CHILD_STATUS.exitstatus).not_to eq 0
         end
 
         context 'with a stubbed command' do
           before do
-            stubbed_env.stub_command('command1')
+            subject.stub_command('command1')
           end
 
           it 'exits with status code 0' do
-            _, _, status = stubbed_env.execute_inline 'command1 "foo bar" 2>&1'
-            expect(status.exitstatus).to eq 0
+            _, _, exitcode = subject.execute_inline 'command1 "foo bar" 2>&1'
+            expect(exitcode.exitstatus).to eq 0
           end
         end
       end

data/spec/integration/stubbed_env/execute_with_stub_wrapper_spec.rb

@@ -1,23 +1,15 @@
-require 'English'
 require 'rspec/bash'
+include Rspec::Bash
 
 describe 'StubbedEnv' do
-  include Rspec::Bash
-  let(:stubbed_env) { create_stubbed_env }
-  let!(:grep_mock) { stubbed_env.stub_command('grep') }
-  let!(:ls_mock) { stubbed_env.stub_command('ls') }
+  subject { create_stubbed_env }
+  let!(:grep_mock) { subject.stub_command('grep') }
 
   context '#execute(<commands that are in stub wrapper>, ...)' do
     it 'does not call the grep command' do
-      stubbed_env.execute_inline('exit 0')
+      subject.execute_inline('exit 0')
 
       expect(grep_mock).to_not be_called
     end
-
-    it 'does not call the ls command' do
-      stubbed_env.execute_inline('exit 0')
-
-      expect(ls_mock).to_not be_called
-    end
   end
 end

data/spec/integration/stubbed_env/override_spec.rb

@@ -0,0 +1,354 @@
+require 'spec_helper'
+include Rspec::Bash
+
+def execute_script(script)
+  let!(:execute_results) do
+    stdout, stderr, status = stubbed_env.execute_inline(
+      script
+    )
+    [stdout, stderr, status]
+  end
+  let(:stdout) { execute_results[0] }
+  let(:stderr) { execute_results[1] }
+  let(:exitcode) { execute_results[2].exitstatus }
+end
+
+def execute_function(script, function)
+  let!(:execute_results) do
+    stdout, stderr, status = stubbed_env.execute_function(
+      script,
+      function
+    )
+    [stdout, stderr, status]
+  end
+  let(:stdout) { execute_results[0] }
+  let(:stderr) { execute_results[1] }
+  let(:exitcode) { execute_results[2].exitstatus }
+end
+
+describe('StubbedEnv override tests') do
+  subject { create_stubbed_env }
+  let(:stubbed_env) { subject }
+
+  let!(:command) do
+    command = subject.stub_command('overridden_command')
+    command.outputs('i was overridden')
+    command.outputs('standard error output', to: :stderr)
+    command
+  end
+  let!(:function) do
+    function = subject.stub_command('overridden_function')
+    function.outputs('i was overridden')
+    function.outputs('standard error output', to: :stderr)
+    function
+  end
+
+  context '#execute_inline' do
+    context 'with a stubbed function' do
+      context 'and no arguments' do
+        execute_script(
+          <<-multiline_script
+            #!/usr/bin/env bash
+            function overridden_function {
+              echo 'i was not overridden'
+            }
+            overridden_function
+
+            echo 'standard error output' 1>&2
+          multiline_script
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+
+        it 'prints provided stderr output to standard error' do
+          expect(stderr.chomp).to eql('standard error outputstandard error output')
+        end
+      end
+
+      context 'and simple arguments' do
+        execute_script(
+          <<-multiline_script
+            #!/usr/bin/env bash
+              function overridden_function {
+                echo 'i was not overridden'
+              }
+              overridden_function argument_one argument_two
+
+              echo 'standard error output' 1>&2
+        multiline_script
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called_with_arguments('argument_one', 'argument_two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and complex arguments (spaces, etc.)' do
+        execute_script(
+          <<-multiline_script
+            #!/usr/bin/env bash
+              function overridden_function {
+                echo 'i was not overridden'
+              }
+              overridden_function "argument one" "argument two"
+
+              echo 'standard error output' 1>&2
+        multiline_script
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called_with_arguments('argument one', 'argument two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+    end
+    context 'with a stubbed command' do
+      context 'and no arguments' do
+        execute_script(
+          <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command
+          multiline_script
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and simple arguments' do
+        execute_script(
+          <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command argument_one argument_two
+          multiline_script
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called_with_arguments('argument_one', 'argument_two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and complex arguments (spaces, etc.)' do
+        execute_script(
+          <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command "argument one" "argument two"
+        multiline_script
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called_with_arguments('argument one', 'argument two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and a path' do
+        context 'relative path' do
+          let!(:path_command) do
+            path_command = subject.stub_command('relative/path/to/overridden_path_command')
+            path_command.outputs('i was overridden in a path')
+          end
+
+          execute_script(
+            'relative/path/to/overridden_path_command'
+          )
+
+          it 'calls the relative path stubbed command' do
+            expect(path_command).to be_called
+          end
+
+          it 'prints the relative path overridden output' do
+            expect(stdout).to eql('i was overridden in a path')
+          end
+        end
+        context 'absolute path' do
+          let!(:path_command) do
+            path_command = subject.stub_command('/absolute/path/to/overridden_path_command')
+            path_command.outputs('i was overridden in a path')
+          end
+
+          execute_script(
+            '/absolute/path/to/overridden_path_command'
+          )
+
+          it 'calls the stubbed command' do
+            expect(path_command).to be_called
+          end
+
+          it 'prints the overridden output' do
+            expect(stdout).to eql('i was overridden in a path')
+          end
+        end
+      end
+    end
+  end
+
+  context '#execute_function' do
+    context 'with a stubbed function' do
+      context 'and no arguments' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_function'
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+
+        it 'prints provided stderr output to standard error' do
+          expect(stderr).to eql("standard error output\n")
+        end
+      end
+
+      context 'and simple arguments' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_function argument_one argument_two'
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called_with_arguments('argument_one', 'argument_two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and complex arguments (spaces, etc.)' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_function "argument one" "argument two"'
+        )
+
+        it 'calls the stubbed function' do
+          expect(function).to be_called_with_arguments('argument one', 'argument two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and a path' do
+        context 'relative path' do
+          let!(:path_function) do
+            path_function = subject.stub_command('relative/path/to/overridden_path_functions')
+            path_function.outputs('i was overridden in a path')
+          end
+
+          execute_function(
+            './spec/scripts/function_library.sh',
+            'relative/path/to/overridden_path_functions'
+          )
+
+          it 'calls the relative path stubbed function' do
+            expect(path_function).to be_called
+          end
+
+          it 'prints the relative path overridden output' do
+            expect(stdout).to eql('i was overridden in a path')
+          end
+        end
+        context 'absolute path' do
+          let!(:path_function) do
+            path_function = subject.stub_command('/absolute/path/to/overridden_path_functions')
+            path_function.outputs('i was overridden in a path')
+          end
+
+          execute_function(
+            './spec/scripts/function_library.sh',
+            '/absolute/path/to/overridden_path_functions'
+          )
+
+          it 'calls the stubbed function' do
+            expect(path_function).to be_called
+          end
+
+          it 'prints the overridden output' do
+            expect(stdout).to eql('i was overridden in a path')
+          end
+        end
+      end
+    end
+    context 'with a stubbed command' do
+      context 'and no arguments' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_command_function'
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+
+        it 'prints provided stderr output to standard error' do
+          expect(stderr.chomp).to eql('standard error outputstandard error output')
+        end
+      end
+
+      context 'and simple arguments' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_command_function argument_one argument_two'
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called_with_arguments('argument_one', 'argument_two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+
+      context 'and complex arguments (spaces, etc.)' do
+        execute_function(
+          './spec/scripts/function_library.sh',
+          'overridden_command_function "argument one" "argument two"'
+        )
+
+        it 'calls the stubbed command' do
+          expect(command).to be_called_with_arguments('argument one', 'argument two')
+        end
+
+        it 'prints the overridden output' do
+          expect(stdout).to eql('i was overridden')
+        end
+      end
+    end
+  end
+end