rspec-bash 0.0.3

data/spec/classes/stubbed_command_spec.rb

@@ -0,0 +1,134 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'StubbedCommand' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  before(:each) do
+    allow(FileUtils).to receive(:cp)
+  end
+
+  context '#called_with_args?' do
+    before(:each) do
+      @call_log = double(Rspec::Bash::CallLog)
+      allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    context 'with only a series of arguments' do
+      it 'passes the check to its CallLog\'s #called_with_args? method' do
+        expect(@call_log).to receive(:called_with_args?).with('first_argument', 'second_argument').and_return(true)
+        @subject.called_with_args?('first_argument', 'second_argument')
+      end
+    end
+  end
+
+  context '#with_args' do
+    before(:each) do
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject.with_args('argument_one', 'argument_two')
+    end
+    it 'sets the arguments array on the StubbedCommand to the arguments that were passed in' do
+      expect(@subject.arguments).to eql %w(argument_one argument_two)
+    end
+  end
+
+  context '#call_count' do
+    before(:each) do
+      @call_log = double(Rspec::Bash::CallLog)
+      allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    it 'returns value returned from call_log argument count when there are no arguments' do
+      expect(@call_log).to receive(:call_count).with([]).and_return('arbitrary return value')
+      expect(@subject.call_count([])).to eql 'arbitrary return value'
+    end
+    it 'returns value returned from call_log argument count when there is only one argument' do
+      expect(@call_log).to receive(:call_count).with(['only arg']).and_return('arbitrary return value')
+      expect(@subject.call_count ['only arg']).to eql 'arbitrary return value'
+    end
+    it 'returns value returned from call_log argument count when there are multiple  arguments' do
+      expect(@call_log).to receive(:call_count).with(['first arg', 'second arg']).and_return('arbitrary return value')
+      expect(@subject.call_count ['first arg', 'second arg']).to eql 'arbitrary return value'
+    end
+  end
+
+  context '#called?' do
+    before(:each) do
+      @call_log = double(Rspec::Bash::CallLog)
+      allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    it 'returns false when there is no call_log' do
+      expect(@call_log).to receive(:exist?).and_return(false)
+      expect(@subject.called?).to be_falsey
+    end
+    it 'returns false when call_log is not called with args' do
+      expect(@call_log).to receive(:exist?).and_return(true)
+      expect(@call_log).to receive(:called_with_args?).and_return(false)
+      expect(@subject.called?).to be_falsey
+    end
+    it 'returns true when call_log is called with args' do
+      expect(@call_log).to receive(:exist?).and_return(true)
+      expect(@call_log).to receive(:called_with_args?).and_return(true)
+      expect(@subject.called?).to be_truthy
+    end
+  end
+  
+  context '#stdin' do
+    before(:each) do
+      @call_log = double(Rspec::Bash::CallLog)
+      allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    it 'returns nil when there is no call_log' do
+      expect(@call_log).to receive(:exist?).and_return(false)
+      expect(@subject.stdin).to be_nil
+    end
+    it 'returns stdin from call log when call_log exists' do
+      expect(@call_log).to receive(:exist?).and_return(true)
+      expect(@call_log).to receive(:stdin_for_args).and_return('arbitrary stdin')
+      expect(@subject.stdin).to eql 'arbitrary stdin'
+    end
+  end
+
+  context '#returns_exitstatus' do
+    before(:each) do
+      @call_configuration = double(Rspec::Bash::CallConfiguration)
+      allow(Rspec::Bash::CallConfiguration).to receive(:new).and_return(@call_configuration)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    it 'sets the exitcode on call_configuration' do
+      expect(@call_configuration).to receive(:set_exitcode).with('exit code', anything)
+      expect(@call_configuration).to receive(:write)
+      @subject.returns_exitstatus 'exit code'
+    end
+    it 'returns itself' do
+      expect(@call_configuration).to receive(:set_exitcode)
+      expect(@call_configuration).to receive(:write)
+      expect(@subject.returns_exitstatus(anything)).to eql @subject
+    end
+  end
+  
+  context '#outputs' do
+    before(:each) do
+      @call_configuration = double(Rspec::Bash::CallConfiguration)
+      allow(Rspec::Bash::CallConfiguration).to receive(:new).and_return(@call_configuration)
+      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+    end
+    it 'sets the output on the call_configuration' do
+      expect(@call_configuration).to receive(:set_output).with('contents', 'stderr', anything)
+      expect(@call_configuration).to receive(:write)
+      @subject.outputs('contents', to: 'stderr')
+    end
+    it 'sets the "to" value for the output to stdout by default' do
+      expect(@call_configuration).to receive(:set_output).with('contents', :stdout, anything)
+      expect(@call_configuration).to receive(:write)
+      @subject.outputs('contents')
+    end
+    it 'returns itself' do
+      expect(@call_configuration).to receive(:set_output)
+      expect(@call_configuration).to receive(:write)
+      expect(@subject.outputs(anything)).to eql @subject
+    end
+  end
+end

data/spec/classes/stubbed_env_spec.rb

@@ -0,0 +1,306 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'StubbedEnv' do
+  include Rspec::Bash
+  let(:subject) { Rspec::Bash::StubbedEnv.new }
+
+  context '#execute_inline' do
+    context 'with a stubbed function' do
+      before(:each) do
+        @overridden_function = subject.stub_command('overridden_function')
+        @overridden_command = subject.stub_command('overridden_command')
+        @overridden_function.outputs('i was overridden')
+      end
+
+      context 'and no arguments' do
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
+            #!/usr/bin/env bash
+            function overridden_function {
+              echo 'i was not overridden'
+            }
+            overridden_function
+
+            echo 'standard error output' 1>&2
+          multiline_script
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-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
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-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
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+      before(:each) do
+        @overridden_command = subject.stub_command('overridden_command')
+        @overridden_function = subject.stub_command('overridden_function')
+        @overridden_command.outputs('i was overridden')
+      end
+
+      context 'and no arguments' do
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
+            #!/usr/bin/env bash
+            overridden_command
+          multiline_script
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
+            #!/usr/bin/env bash
+            overridden_command argument_one argument_two
+          multiline_script
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
+            #!/usr/bin/env bash
+            overridden_command "argument one" "argument two"
+          multiline_script
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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
+
+  context '#execute_function' do
+    context 'with a stubbed function' do
+      before(:each) do
+        @overridden_function = subject.stub_command('overridden_function')
+        @overridden_command = subject.stub_command('overridden_command')
+        @overridden_function.outputs('i was overridden')
+        @overridden_function.outputs('standard error output', to: :stderr)
+      end
+
+      context 'and no arguments' do
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_function'
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_function argument_one argument_two'
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_function "argument one" "argument two"'
+          )
+        end
+
+        it 'calls the stubbed function' do
+          expect(@overridden_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
+      before(:each) do
+        @overridden_function = subject.stub_command('overridden_function')
+        @overridden_command = subject.stub_command('overridden_command')
+        @overridden_command.outputs('i was overridden')
+      end
+
+      context 'and no arguments' do
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_command_function'
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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).to eql("standard error output\n")
+        end
+      end
+
+      context 'and simple arguments' do
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_command_function argument_one argument_two'
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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
+        before(:each) do
+          @stdout, @stderr, @status = subject.execute_function(
+              './spec/scripts/function_library.sh',
+              'overridden_command_function "argument one" "argument two"'
+          )
+        end
+
+        it 'calls the stubbed command' do
+          expect(@overridden_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
+
+  describe 'creating a stubbed env' do
+    it 'extends the PATH with the stubbed folder first' do
+      expect { create_stubbed_env }.to change { ENV['PATH'] }
+    end
+
+    it 'creates a folder to place the stubbed commands in' do
+      env = create_stubbed_env
+      expect(Pathname.new(env.dir)).to exist
+      expect(Pathname.new(env.dir)).to be_directory
+    end
+  end
+
+  describe '#cleanup' do
+    it 'restores the environment variable PATH' do
+      original_path = ENV['PATH']
+      env = create_stubbed_env
+
+      expect { env.cleanup }.to change { ENV['PATH'] }.to original_path
+    end
+
+    it 'removes the folder with stubbed commands' do
+      env = create_stubbed_env
+      env.cleanup
+      expect(Pathname.new(env.dir)).not_to exist
+    end
+  end
+end

data/spec/integration/assert_called_spec.rb

@@ -0,0 +1,48 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Assert called' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:first_command) { stubbed_env.stub_command('first_command') }
+
+  let(:script) do
+    <<-SCRIPT
+      first_command "foo bar"
+    SCRIPT
+  end
+  let(:script_path) { Pathname.new '/tmp/test_script.sh' }
+
+  before do
+    script_path.open('w') { |f| f.puts script }
+    script_path.chmod 0777
+
+    stubbed_env.execute script_path.to_s
+  end
+
+  after do
+    script_path.delete
+  end
+
+  describe 'assert called' do
+    it 'returns called status' do
+      expect(first_command).to be_called
+    end
+
+    context 'assert with args' do
+      it 'returns called status' do
+        expect(first_command).to be_called_with_arguments('foo bar')
+        expect(first_command).to be_called_with_arguments(anything)
+        expect(first_command).not_to be_called_with_arguments('foot')
+      end
+    end
+
+    describe 'assertion message' do
+      it 'provides a helpful message' do
+        expect(first_command.inspect).to eql '<Stubbed "first_command">'
+        expect(first_command.with_args('foo bar').inspect).to \
+          eql '<Stubbed "first_command" args: "foo bar">'
+      end
+    end
+  end
+end