rspec-bash 0.0.3

data/spec/integration/assert_stdin_spec.rb

@@ -0,0 +1,39 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Assert stdin' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:command1_stub) { stubbed_env.stub_command('command1') }
+
+  let(:script) do
+    <<-SCRIPT
+      echo "foo bar" | command1
+      echo "baz" | command1 'hello'
+    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 '#stdin' do
+    it 'returns the stdin' do
+      expect(command1_stub.stdin).to match 'foo bar'
+    end
+
+    context 'with arguments' do
+      it 'returns the stdin' do
+        expect(command1_stub.with_args('hello').stdin).to match 'baz'
+      end
+    end
+  end
+end

data/spec/integration/chain_args_spec.rb

@@ -0,0 +1,65 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Assert called' do
+  context 'checking command is called with argument sequence' do
+    include Rspec::Bash
+    let(:stubbed_env) { create_stubbed_env }
+    let!(:bundle) {
+      stubbed_env.stub_command('bundle')
+    }
+
+    let(:script) do
+      <<-SCRIPT
+        bundle exec rake 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
+
+    it 'is called with correct argument sequence' do
+      expect(bundle).to be_called_with_arguments('exec', 'rake', 'foo:bar')
+      expect(bundle).to be_called_with_arguments('exec', anything, 'foo:bar')
+      expect(bundle).not_to be_called_with_arguments('exec', 'rake', 'foo')
+    end
+  end
+  context 'checking command is called with no arguments' do
+    include Rspec::Bash
+    let(:stubbed_env) { create_stubbed_env }
+    let!(:ls) {
+      stubbed_env.stub_command('ls')
+    }
+
+    let(:script) do
+      <<-SCRIPT
+       ls
+      SCRIPT
+    end
+    let(:script_path) { Pathname.new '/tmp/no_arg_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
+
+    it 'is called with no arguments' do
+      expect(ls).to be_called_with_no_arguments
+    end
+  end
+end

data/spec/integration/change_exitstatus_spec.rb

@@ -0,0 +1,53 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Change exitstatus' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:command1_stub) { stubbed_env.stub_command('command1') }
+  let(:script) do
+    <<-SCRIPT
+      command1 "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
+  end
+
+  after do
+    script_path.delete
+  end
+
+  describe 'default exitstatus' do
+    it 'is 0' do
+      output, error, status = stubbed_env.execute script_path.to_s
+      expect(status.exitstatus).to eq 0
+    end
+  end
+
+  describe 'changing exitstatus' do
+    before do
+      command1_stub.returns_exitstatus(4)
+    end
+
+    it 'returns the stubbed exitstatus' do
+      output, error, status = stubbed_env.execute script_path.to_s
+      expect(status.exitstatus).to eq 4
+    end
+
+    context 'with specific args only' do
+      before do
+        command1_stub.with_args('foo bar').returns_exitstatus(2)
+        command1_stub.with_args('bar').returns_exitstatus(6)
+      end
+
+      it 'returns the stubbed exitstatus' do
+        output, error, status = stubbed_env.execute script_path.to_s
+        expect(status.exitstatus).to eq 2
+      end
+    end
+  end
+end

data/spec/integration/provide_env_vars_spec.rb

@@ -0,0 +1,31 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Provide environment vars' do
+  include Rspec::Bash
+  let(:script) do
+    <<-SCRIPT
+      echo $SOME_ENV_VAR
+    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
+  end
+
+  after do
+    script_path.delete
+  end
+
+  let(:stubbed_env) { create_stubbed_env }
+
+  it 'exits with an error' do
+    o, _e, _s = stubbed_env.execute(
+      script_path,
+      'SOME_ENV_VAR' => 'SekretCredential'
+    )
+    expect(o).to eql "SekretCredential\n"
+  end
+end

data/spec/integration/replace_shell_commands_spec.rb

@@ -0,0 +1,48 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Replace shell commands' do
+  include Rspec::Bash
+  let(:script) do
+    <<-SCRIPT
+      command1 "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
+  end
+
+  after do
+    script_path.delete
+  end
+
+  describe 'running a file with non-existing commands' do
+    it 'exits with an error' do
+      `#{script_path} 2>&1`
+      expect($CHILD_STATUS.exitstatus).not_to eq 0
+    end
+
+    context 'with stubbed environment' do
+      let(:stubbed_env) { create_stubbed_env }
+
+      it 'exits with an error' do
+        stubbed_env.execute "#{script_path} 2>&1"
+        expect($CHILD_STATUS.exitstatus).not_to eq 0
+      end
+
+      context 'with a stubbed command' do
+        before do
+          stubbed_env.stub_command('command1')
+        end
+
+        it 'exits with status code 0' do
+          _o, _e, s = stubbed_env.execute "#{script_path} 2>&1"
+          expect(s.exitstatus).to eq 0
+        end
+      end
+    end
+  end
+end

data/spec/integration/stub_output_spec.rb

@@ -0,0 +1,110 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'Stub command output' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:command1_stub) { stubbed_env.stub_command('command1') }
+
+  let(:script) do
+    <<-SCRIPT
+      command1
+    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
+  end
+
+  after do
+    script_path.delete
+  end
+
+  describe 'stubbing standard-out' do
+    it 'changes standard-out' do
+      command1_stub.outputs('hello', to: :stdout)
+      output, error, status = stubbed_env.execute "#{script_path} 2>/dev/null"
+
+      expect(output).to eql 'hello'
+      expect(error).to be_empty
+    end
+  end
+
+  describe 'stubbing standard-err' do
+    it 'changes standard-out' do
+      command1_stub.outputs('world', to: :stderr)
+      output, error, status = stubbed_env.execute "#{script_path} 1>/dev/null"
+      expect(error).to eql "world\n"
+      expect(output).to be_empty
+    end
+  end
+
+  describe 'stubbing contents to file' do
+    let(:filename) { 'test-log.nice' }
+    after do
+      f = Pathname.new(filename)
+      f.delete if f.exist?
+    end
+
+    it 'write data to a file' do
+      command1_stub.outputs('world', to: filename)
+      output, error, status = stubbed_env.execute "#{script_path}"
+
+      expect(error).to be_empty
+      expect(output).to be_empty
+      expect(Pathname.new(filename).read).to eql 'world'
+    end
+
+    describe 'using passed argument as filename' do
+      let(:script) do
+        <<-SCRIPT
+          command1 input output
+        SCRIPT
+      end
+
+      let(:passed_filename) { ['hello-', :arg2, '.foo'] }
+      let(:filename) { 'hello-output.foo' }
+
+      it 'writes data to an interpolated filename' do
+        command1_stub.outputs('world', to: passed_filename)
+        stubbed_env.execute "#{script_path}"
+
+        expect(Pathname.new(filename).read).to eql 'world'
+      end
+    end
+  end
+
+  describe 'stubbing commands with arguments passed to stdout' do
+    let(:script) do
+      <<-SCRIPT
+        command1 input output
+      SCRIPT
+    end
+
+    it 'outputs correctly when all arguments match' do
+      command1_stub.with_args('input', 'output').outputs('world', to: :stdout)
+      output, error, status = stubbed_env.execute "#{script_path}"
+
+      expect(error).to be_empty
+      expect(output).to eql 'world'
+    end
+
+    it 'does not output when called with extra arguments, even if some match' do
+      command1_stub.with_args('input', 'output', 'anything').outputs('arbitrary string', to: :stdout)
+      output, error, status = stubbed_env.execute "#{script_path}"
+
+      expect(error).to be_empty
+      expect(output).to be_empty
+    end
+
+    it 'does not output when called with only one matching argument out of many' do
+      command1_stub.with_args('input').outputs('arbitrary string', to: :stdout)
+      output, error, status = stubbed_env.execute "#{script_path}"
+
+      expect(error).to be_empty
+      expect(output).to be_empty
+    end
+  end
+end

data/spec/matchers/be_called_with_arguments_spec.rb

@@ -0,0 +1,55 @@
+require 'English'
+require 'rspec/bash'
+
+# TODO - the below specs test implementation, until the goofy wiring of StubbedCommand => StubbedCall => CallLog is sorted out
+
+describe 'be_called_with_arguments' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+
+  context 'with a command' do
+    context 'and no chain calls' do
+      before(:each) do
+        @command = stubbed_env.stub_command('stubbed_command')
+        @actual_stdout, @actual_stderr, @actual_status = stubbed_env.execute_inline(<<-multiline_script
+          stubbed_command first_argument second_argument
+        multiline_script
+        )
+      end
+      it 'correctly identifies the called arguments' do
+        expect(@command).to be_called_with_arguments('first_argument', 'second_argument')
+      end
+      it 'correctly matches when wildcard is used for first argument' do
+        expect(@command).to be_called_with_arguments(anything, 'second_argument')
+      end
+      it 'correctly matches when wildcard is used for second argument' do
+        expect(@command).to be_called_with_arguments('first_argument', anything)
+      end
+      it 'correctly matches when wildcard is used for all arguments' do
+        expect(@command).to be_called_with_arguments(anything, anything)
+      end
+    end
+    context 'and the times chain call' do
+      before(:each) do
+        @command = stubbed_env.stub_command('stubbed_command')
+        @actual_stdout, @actual_stderr, @actual_status = stubbed_env.execute_inline(<<-multiline_script
+          stubbed_command duplicated_argument once_called_argument
+          stubbed_command duplicated_argument irrelevant_argument
+        multiline_script
+        )
+      end
+      it 'matches when arguments are called twice' do
+        expect(@command).to be_called_with_arguments('duplicated_argument', anything).times(2)
+      end
+      it 'matches when argument is called once' do
+        expect(@command).to be_called_with_arguments(anything, 'once_called_argument').times(1)
+      end
+      it 'matches when argument combination is called once' do
+        expect(@command).to be_called_with_arguments('duplicated_argument', 'once_called_argument').times(1)
+      end
+      it 'matches when argument is not called' do
+        expect(@command).to_not be_called_with_arguments('not_called_argument').times(1)
+      end
+    end
+  end
+end

data/spec/matchers/be_called_with_no_arguments_spec.rb

@@ -0,0 +1,32 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'be_called_with_no_arguments' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+
+  context 'when command is called with no args' do
+    before(:each) do
+      @command = stubbed_env.stub_command('stubbed_command')
+      @actual_stdout, @actual_stderr, @actual_status = stubbed_env.execute_inline(<<-multiline_script
+        stubbed_command
+      multiline_script
+      )
+    end
+    it 'correctly identifies that no arguments were called' do
+      expect(@command).to be_called_with_no_arguments
+    end
+  end
+  context 'when command is called with args' do
+    before(:each) do
+      @command = stubbed_env.stub_command('stubbed_command')
+      @actual_stdout, @actual_stderr, @actual_status = stubbed_env.execute_inline(<<-multiline_script
+        stubbed_command argument
+      multiline_script
+      )
+    end
+    it 'correctly identifies that arguments were passed into command call' do
+      expect(@command).to_not be_called_with_no_arguments
+    end
+  end
+end

data/spec/scripts/function_library.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+function overridden_function {
+  echo 'i was not overridden'
+}
+
+function overridden_command_function {
+  overridden_command "${1}" "${2}"
+  echo 'standard error output' >&2
+}