rspec-bash 0.0.3

data/lib/rspec/bash/call_log.rb

@@ -0,0 +1,77 @@
+module Rspec
+  module Bash
+    # Log of calls to a command
+    class CallLog
+      def initialize(call_log_path)
+        @call_log_path = call_log_path
+      end
+
+      def exist?
+        @call_log_path.exist?
+      end
+
+      def called_with_args?(*args)
+        call_count(*args) > 0
+      end
+
+      def stdin_for_args(*args)
+        call = find_call(*args)
+        call['stdin'] unless call.nil?
+      end
+
+      def call_count(*expected_argument_series)
+        get_call_log_args.count do |actual_argument_series|
+          argument_series_contains?(actual_argument_series, expected_argument_series || [])
+        end
+      end
+
+      def called_with_no_args?
+        call_log_list = load_call_log_list
+        !call_log_list.empty? && call_log_list.first['args'].nil?
+      end
+
+      private
+
+      def find_call(*args)
+        load_call_log_list.find do |call|
+          call_args = call['args'] || []
+          (args - call_args).empty?
+        end
+      end
+
+      def get_position_range_from_argument_list(argument_list, range_start_position, range_length)
+        argument_list.map do |argument_series|
+          range_start_position ? argument_series[range_start_position, range_length] : argument_series
+        end
+      end
+
+      def get_call_log_args
+        load_call_log_list.map { |call_log| call_log["args"] || [] }.compact
+      end
+
+      def argument_series_contains?(actual_argument_series, expected_argument_series)
+        ensure_wildcards_match(actual_argument_series, expected_argument_series)
+        expected_argument_series.empty? || (actual_argument_series == expected_argument_series)
+      end
+
+      def ensure_wildcards_match(actual_argument_series, expected_argument_series)
+        # yes, i know. i am disappointed in myself
+        num_of_args = actual_argument_series.size
+        expected_argument_series.zip((0..num_of_args), actual_argument_series) do |expected_arg, index, _actual_arg|
+          if expected_arg.is_a? RSpec::Mocks::ArgumentMatchers::AnyArgMatcher
+            actual_argument_series[index] = expected_arg
+          end
+        end
+      end
+
+      def load_call_log_list
+        begin
+          YAML.load_file @call_log_path
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+
+    end
+  end
+end

data/lib/rspec/bash/matchers.rb

@@ -0,0 +1,2 @@
+require 'rspec/bash/matchers/called_with_arguments'
+require 'rspec/bash/matchers/called_with_no_arguments'

data/lib/rspec/bash/matchers/called_with_arguments.rb

@@ -0,0 +1,14 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_called_with_arguments do |*expected_argument_list|
+  chain :times do |expected_invocations|
+    @expected_invocations = expected_invocations
+  end
+  
+  match do |actual_command|
+    called_with_correct_args = actual_command.called_with_args?(*expected_argument_list)
+    called_correct_number_of_times = @expected_invocations ? actual_command.call_count(*expected_argument_list) == @expected_invocations : true
+
+    called_with_correct_args && called_correct_number_of_times
+  end
+end

data/lib/rspec/bash/matchers/called_with_no_arguments.rb

@@ -0,0 +1,5 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_called_with_no_arguments do
+  match(&:called_with_no_args?)
+end

data/lib/rspec/bash/stubbed_command.rb

@@ -0,0 +1,76 @@
+module Rspec
+  module Bash
+    class StubbedCommand
+      attr_reader :call_log, :arguments
+
+      def initialize(command, dir)
+        command_path = File.join(dir, command)
+        FileUtils.cp(stub_filepath, command_path)
+        @arguments = []
+        @call_configuration = CallConfiguration.new(
+          Pathname.new(dir).join("#{command}_stub.yml"),
+          command
+        )
+        @call_log = CallLog.new(
+          Pathname.new(dir).join("#{command}_calls.yml")
+        )
+      end
+
+      def with_args(*args)
+        @arguments = args
+        self
+      end
+
+      def called?
+        @call_log.exist? && @call_log.called_with_args?(*@args)
+      end
+
+      def called_with_no_args?
+        @call_log.called_with_no_args?
+      end
+
+      def called_with_args?(*args)
+        @call_log.called_with_args?(*args)
+      end
+
+      def call_count(*arg)
+        @call_log.call_count(*arg)
+      end
+
+      def returns_exitstatus(statuscode)
+        @call_configuration.set_exitcode(statuscode, @arguments)
+        @call_configuration.write
+        self
+      end
+
+      def stdin
+        @call_log.stdin_for_args(*@arguments) if @call_log.exist?
+      end
+
+      def outputs(contents, to: :stdout)
+        @call_configuration.set_output(contents, to, @arguments)
+        @call_configuration.write
+        self
+      end
+
+      def inspect
+        if @arguments.any?
+          "<Stubbed #{@call_configuration.command.inspect} " \
+            "args: #{@arguments.join(' ').inspect}>"
+        else
+          "<Stubbed #{@call_configuration.command.inspect}>"
+        end
+      end
+
+      private
+
+      def stub_filepath
+        project_root.join('bin', 'stub')
+      end
+
+      def project_root
+        Pathname.new(File.dirname(File.expand_path(__FILE__))).join('..', '..', '..')
+      end
+    end
+  end
+end

data/lib/rspec/bash/stubbed_env.rb

@@ -0,0 +1,99 @@
+require 'tmpdir'
+require 'English'
+require 'open3'
+
+module Rspec
+  # Define stubbed environment to set and assert expectations
+  module Bash
+    def create_stubbed_env
+      StubbedEnv.new
+    end
+
+    # A shell environment that can manipulate behaviour
+    # of executables
+    class StubbedEnv
+      attr_reader :dir
+
+      def initialize
+        @dir = Dir.mktmpdir
+        ENV['PATH'] = "#{@dir}:#{ENV['PATH']}"
+        at_exit { cleanup }
+      end
+
+      def cleanup
+        paths = (ENV['PATH'].split ':') - [@dir]
+        ENV['PATH'] = paths.join ':'
+        FileUtils.remove_entry_secure @dir if Pathname.new(@dir).exist?
+      end
+
+      def stub_command(command)
+        write_function_override_file_for_command command
+        StubbedCommand.new command, @dir
+      end
+
+      def execute(command, env_vars = {})
+        full_command = get_wrapped_execution_with_function_overrides(<<-multiline_script
+          #{env} source #{command}
+        multiline_script
+        )
+
+        Open3.capture3(env_vars, full_command)
+      end
+
+      def execute_function(script, command, env_vars = {})
+        full_command = get_wrapped_execution_with_function_overrides(<<-multiline_script
+          source #{script}
+          #{env} #{command}
+        multiline_script
+        )
+
+        Open3.capture3(env_vars, full_command)
+      end
+
+      def execute_inline(command_string, env_vars = {})
+        temp_command_path = Dir::Tmpname.make_tmpname("#{@dir}/inline-", nil)
+        File.write(temp_command_path, command_string)
+        execute(temp_command_path, env_vars)
+      end
+
+      private
+
+      def write_function_override_file_for_command(command)
+        function_command_binding_for_template = command
+        function_command_path_binding_for_template = File.join(@dir, command)
+
+        function_override_file_path = File.join(@dir, "#{command}_overrides.sh")
+        function_override_file_template = ERB.new File.new(function_override_template_path).read, nil, '%'
+        function_override_file_content = function_override_file_template.result(binding)
+
+        File.write(function_override_file_path, function_override_file_content)
+      end
+
+      def get_wrapped_execution_with_function_overrides(execution_snippet)
+        execution_binding_for_template = execution_snippet
+        function_override_path_binding_for_template = "#{@dir}/*_overrides.sh"
+        wrapped_error_path_binding_for_template = "#{@dir}/errors"
+
+        function_override_wrapper_template = ERB.new File.new(function_override_wrapper_template_path).read, nil, '%'
+
+        function_override_wrapper_template.result(binding)
+      end
+
+      def env
+        "PATH=#{@dir}:$PATH"
+      end
+
+      def function_override_template_path
+        project_root.join('bin', 'function_override.sh.erb')
+      end
+
+      def function_override_wrapper_template_path
+        project_root.join('bin', 'function_override_wrapper.sh.erb')
+      end
+
+      def project_root
+        Pathname.new(File.dirname(File.expand_path(__FILE__))).join('..', '..', '..')
+      end
+    end
+  end
+end

data/rspec-bash.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rspec-bash'
+  spec.version       = '0.0.3'
+  spec.authors       = ['Ben Brewer', 'Mike Urban', 'Matthijs Groen']
+  spec.email         = ['ben@benbrewer.me', 'mike.david.urban@gmail.com']
+  spec.summary       = 'Test Bash with RSpec'
+  spec.description   = <<-DESCRIPTION
+    Stub and mock Bash commands
+    Verify Bash calls and outputs
+  DESCRIPTION
+  spec.homepage      = 'https://github.com/mdurban/rspec-bash'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/spec/classes/call_configuration_spec.rb

@@ -0,0 +1,21 @@
+require 'rspec/bash'
+
+describe 'CallConfiguration' do
+  let(:stubbed_env) { create_stubbed_env }
+  include Rspec::Bash
+
+  context '#set_exitcode' do
+    it 'returns the status code that is provided' do
+      @subject = Rspec::Bash::CallConfiguration.new(anything, anything)
+
+      expect(@subject.set_exitcode('status')).to eql 'status'
+    end
+  end
+  context '#write' do
+      it 'raises error when there is no config_path' do
+      @subject = Rspec::Bash::CallConfiguration.new(nil, anything)
+
+      expect { @subject.write }.to raise_exception(NoMethodError)
+    end
+  end
+end

data/spec/classes/call_log_spec.rb

@@ -0,0 +1,309 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'CallLog' do
+  let(:stubbed_env) { create_stubbed_env }
+  include Rspec::Bash
+
+  context '#stdin_for_args' do
+    it 'returns nil when no YAML file is used for call log' do
+        @subject = Rspec::Bash::CallLog.new(anything)
+        allow(YAML).to receive(:load_file).and_return([])
+
+        expect(@subject.stdin_for_args(anything)).to be nil
+    end
+    it 'returns the stdin from call log when there is a single value for stdin' do
+      actual_call_log_list =
+        [{
+           'args' => ['arbitrary argument'],
+           'stdin' => ['correct value'],
+        }]
+      @subject = Rspec::Bash::CallLog.new(anything)
+      allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+      expect(@subject.stdin_for_args('arbitrary argument').first).to eql 'correct value'
+    end
+    it 'returns the stdin from call log when there are multiple values for stdin' do
+      actual_call_log_list =
+        [{
+           'args' => ['arbitrary argument'],
+           'stdin' => ['first value', 'second value'],
+        }]
+      @subject = Rspec::Bash::CallLog.new(anything)
+      allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+      expect(@subject.stdin_for_args('arbitrary argument').sort).to eql ['first value', 'second value'].sort
+    end
+    it 'returns the stdin from call log when no arguments are provided' do
+      actual_call_log_list =
+        [{
+           'args' => nil,
+           'stdin' => ['correct value'],
+         }]
+      @subject = Rspec::Bash::CallLog.new(anything)
+      allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+      expect(@subject.stdin_for_args).to eql ['correct value']
+    end
+  end
+
+  context '#call_count?' do
+    context 'with no calls made at all (missing call log file)' do
+      before(:each) do
+        @subject = Rspec::Bash::CallLog.new('command_with_no_call_log_file')
+        allow(YAML).to receive(:load_file).and_raise(Errno::ENOENT)
+      end
+
+      it 'does not find an un-passed argument anywhere in the series' do
+        expect(@subject.call_count('not_an_argument')).to eql 0
+      end
+    end
+    context 'with only an series of arguments provided' do
+      context 'and a command log with only one argument' do
+        before(:each) do
+          actual_call_log_list =
+              [{
+                   'args' => ['first_argument'],
+                   'stdin' => [],
+               }]
+          @subject = Rspec::Bash::CallLog.new('command_with_one_argument_log')
+          allow(@subject).to receive(:load_call_log_list).and_return(actual_call_log_list)
+        end
+
+        it 'finds the single argument anywhere in the series exactly once' do
+          expect(@subject.call_count('first_argument')).to eql 1
+        end
+
+        it 'does not find an un-passed argument anywhere in the series' do
+          expect(@subject.call_count('not_an_argument')).to eql 0
+        end
+
+        it 'finds the single wildcard argument exactly once' do
+          expect(@subject.call_count(anything)).to eql 1
+        end
+      end
+      context 'and a command called with two arguments' do
+        before(:each) do
+          actual_call_log_list =
+              [{
+                   'args' => ['first_argument', 'second_argument'],
+                   'stdin' => [],
+               }]
+          @subject = Rspec::Bash::CallLog.new('command_with_two_arguments_log')
+          allow(@subject).to receive(:load_call_log_list).and_return(actual_call_log_list)
+        end
+        
+        it 'does not find the first argument when other argument is not provided' do
+          expect(@subject.call_count('first_argument')).to eql 0
+        end
+
+        it 'finds the first argument anywhere in the series exactly once' do
+          expect(@subject.call_count('first_argument', anything)).to eql 1
+        end
+
+        it 'does not find the second argument when first argument is not provided' do
+          expect(@subject.call_count('second_argument')).to eql 0
+        end
+
+        it 'finds the second argument anywhere in the series exactly once' do
+          expect(@subject.call_count(anything, 'second_argument')).to eql 1
+        end
+
+        it 'finds two contiguous arguments in the series exactly once' do
+          expect(@subject.call_count('first_argument', 'second_argument')).to eql 1
+        end
+
+        it 'does not find an un-passed argument anywhere in the series' do
+          expect(@subject.call_count('not_an_argument')).to eql 0
+        end
+
+        it 'does not find a wildcard argument when other argument is not provided' do
+          expect(@subject.call_count(anything)).to eql 0
+        end
+
+        it 'finds when both arguments are wildcards exactly once' do
+          expect(@subject.call_count(anything, anything)).to eql 1
+        end
+
+        it 'finds when only the first argument is a wildcard exactly once' do
+          expect(@subject.call_count(anything, 'second_argument')).to eql 1
+        end
+
+        it 'finds when only the second argument is a wildcard exactly once' do
+          expect(@subject.call_count('first_argument', anything)).to eql 1
+        end
+
+        it 'does not find when wildcard is in wrong position' do
+          expect(@subject.call_count('first_argument', anything, 'second_argument')).to eql 0
+        end
+      end
+      context 'and a command called with three arguments' do
+        before(:each) do
+          actual_call_log_list =
+              [{
+                   'args' => ['first_argument', 'second_argument', 'third_argument'],
+                   'stdin' => [],
+               }]
+          @subject = Rspec::Bash::CallLog.new('command_with_three_arguments_log')
+          allow(@subject).to receive(:load_call_log_list).and_return(actual_call_log_list)
+        end
+
+        it 'does not find first argument when other arguments are not provided' do
+          expect(@subject.call_count('first_argument')).to eql 0
+        end
+
+        it 'finds the first argument anywhere in the series exactly once' do
+          expect(@subject.call_count('first_argument', anything, anything)).to eql 1
+        end
+
+        it 'does not find second argument when other arguments are not provided' do
+          expect(@subject.call_count('second_argument')).to eql 0
+        end
+
+        it 'finds the second argument anywhere in the series exactly once' do
+          expect(@subject.call_count(anything, 'second_argument', anything)).to eql 1
+        end
+
+        it 'does not find third argument when other arguments are not provided' do
+          expect(@subject.call_count('third_argument')).to eql 0
+        end
+
+        it 'finds the third argument anywhere in the series exactly once' do
+          expect(@subject.call_count(anything, anything, 'third_argument')).to eql 1
+        end
+
+        it 'finds three contiguous arguments in the series exactly once' do
+          expect(@subject.call_count('first_argument', 'second_argument', 'third_argument')).to eql 1
+        end
+
+        it 'does not find two non-contiguous arguments in the series exactly once' do
+          expect(@subject.call_count('first_argument', 'third_argument')).to eql 0
+        end
+
+        it 'does not find an un-passed argument anywhere in the series' do
+          expect(@subject.call_count('not_an_argument')).to eql 0
+        end
+
+        it 'finds when only the first argument is a wildcard' do
+          expect(@subject.call_count(anything, 'second_argument', 'third_argument')).to eql 1
+        end
+
+        it 'finds when only the second argument is a wildcard' do
+          expect(@subject.call_count('first_argument', anything, 'third_argument')).to eql 1
+        end
+
+        it 'finds when only the third argument is a wildcard' do
+          expect(@subject.call_count('first_argument', 'second_argument', anything)).to eql 1
+        end
+
+        it 'finds when both the first and second arguments are wildcards' do
+          expect(@subject.call_count(anything, anything, 'third_argument')).to eql 1
+        end
+
+        it 'finds when both the first and third arguments are wildcards' do
+          expect(@subject.call_count(anything, 'second_argument', anything)).to eql 1
+        end
+
+        it 'finds when both the second and third arguments are wildcards' do
+          expect(@subject.call_count('first_argument', anything, anything)).to eql 1
+        end
+        
+        it 'does not find when wildcard is in wrong position' do
+          expect(@subject.call_count('first_argument', anything, 'second_argument', 'third_argument')).to eql 0
+        end
+      end
+      context 'with an argument called multiple times' do
+        before(:each) do
+          actual_call_log_list =
+              [{
+                   'args' => ['twice_called_arg'],
+                   'stdin' => []
+               },
+               {
+                   'args' => ['twice_called_arg'],
+                   'stdin' => []
+               }]
+          @subject = Rspec::Bash::CallLog.new(anything)
+          allow(@subject).to receive(:load_call_log_list).and_return(actual_call_log_list)
+        end
+        it 'returns 2 when argument is called 2 times' do
+          expect(@subject.call_count('twice_called_arg')).to eql 2
+        end
+      end
+    end
+  end
+
+  context '#called_with_args' do
+    before(:each) do
+      actual_call_log_list =
+          [{
+               'args' => ['once_called_arg'],
+               'stdin' => []
+           },
+           {
+               'args' => ['twice_called_arg'],
+               'stdin' => []
+           },
+           {
+               'args' => ['twice_called_arg'],
+               'stdin' => []
+           }]
+      @subject = Rspec::Bash::CallLog.new(anything)
+      allow(@subject).to receive(:load_call_log_list).and_return(actual_call_log_list)
+    end
+
+    it 'returns false when there are no matching args' do
+      expect(@subject.called_with_args?('no-match')).to be_falsey
+    end
+    
+    it 'returns true when there is a single matching arg' do
+      expect(@subject.called_with_args?('once_called_arg', anything)).to be_truthy
+    end
+    
+    it 'returns true when there are multiple matching args' do
+      expect(@subject.called_with_args?('twice_called_arg')).to be_truthy
+    end
+  end
+
+  context '#called_with_no_args?' do
+    it 'returns false if no call log is found' do
+        @subject = Rspec::Bash::CallLog.new(anything)
+        allow(YAML).to receive(:load_file).and_raise(Errno::ENOENT)
+
+        expect(@subject.called_with_no_args?).to be_falsey
+    end
+    it 'returns true if no arguments are in call log' do
+      actual_call_log_list =
+        [{
+           'args' => nil,
+           'stdin' => [],
+        }]
+        @subject = Rspec::Bash::CallLog.new(anything)
+        allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+        expect(@subject.called_with_no_args?).to be_truthy
+    end
+    it 'returns fails if a single argument is in call log' do
+      actual_call_log_list =
+        [{
+           'args' => ['I am an argument'],
+           'stdin' => [],
+        }]
+        @subject = Rspec::Bash::CallLog.new(anything)
+        allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+        expect(@subject.called_with_no_args?).to be_falsey
+    end
+    it 'returns fails if multiple arguments is in call log' do
+      actual_call_log_list =
+        [{
+           'args' => ['I am an argument', 'as am I'],
+           'stdin' => [],
+        }]
+        @subject = Rspec::Bash::CallLog.new(anything)
+        allow(YAML).to receive(:load_file).and_return(actual_call_log_list)
+
+        expect(@subject.called_with_no_args?).to be_falsey
+    end
+  end
+end