rspec-bash 0.0.3 → 0.1.0

data/lib/rspec/bash/call_log.rb

@@ -1,6 +1,5 @@
 module Rspec
   module Bash
-    # Log of calls to a command
     class CallLog
       def initialize(call_log_path)
         @call_log_path = call_log_path
@@ -10,68 +9,59 @@ module Rspec
         @call_log_path.exist?
       end
 
-      def called_with_args?(*args)
-        call_count(*args) > 0
+      def stdin_for_args(*argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(*argument_list)
+        matching_call_log_list = call_argument_list_matcher.get_call_log_matches(call_log)
+        matching_call_log_list.first[:stdin] unless matching_call_log_list.empty?
       end
 
-      def stdin_for_args(*args)
-        call = find_call(*args)
-        call['stdin'] unless call.nil?
+      def call_count(*argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(*argument_list)
+        call_argument_list_matcher.get_call_count(call_log)
       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
+      def called_with_args?(*argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(*argument_list)
+        call_argument_list_matcher.args_match?(call_log)
       end
 
       def called_with_no_args?
-        call_log_list = load_call_log_list
-        !call_log_list.empty? && call_log_list.first['args'].nil?
-      end
+        return false if call_log.empty?
 
-      private
-
-      def find_call(*args)
-        load_call_log_list.find do |call|
-          call_args = call['args'] || []
-          (args - call_args).empty?
+        call_log.all? do |call_log|
+          argument_list = call_log[:args] || []
+          argument_list.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
+      def add_log(stdin, argument_list)
+        updated_log = call_log
+        updated_log << {
+          args: argument_list,
+          stdin: stdin
+        }
+        write updated_log
       end
 
-      def get_call_log_args
-        load_call_log_list.map { |call_log| call_log["args"] || [] }.compact
+      def call_log
+        @call_log_path.open('r') do |call_log|
+          YAML.load(call_log.read) || []
+        end
+      rescue NoMethodError, Errno::ENOENT
+        return []
       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)
+      def call_log=(new_log)
+        write new_log
       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
+      private
 
-      def load_call_log_list
-        begin
-          YAML.load_file @call_log_path
-        rescue Errno::ENOENT
-          return []
+      def write(call_log_to_write)
+        @call_log_path.open('w') do |call_log|
+          call_log.write call_log_to_write.to_yaml
         end
       end
-
     end
   end
 end

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

@@ -4,10 +4,15 @@ 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
+    if @expected_invocations
+      called_correct_number_of_times =
+        actual_command.call_count(*expected_argument_list) == @expected_invocations
+    else
+      called_correct_number_of_times = true
+    end
 
     called_with_correct_args && called_correct_number_of_times
   end

data/lib/rspec/bash/stubbed_command.rb

@@ -1,11 +1,10 @@
 module Rspec
   module Bash
     class StubbedCommand
-      attr_reader :call_log, :arguments
+      attr_reader :call_log, :arguments, :path
 
       def initialize(command, dir)
-        command_path = File.join(dir, command)
-        FileUtils.cp(stub_filepath, command_path)
+        @path = create_stub_file(command, dir)
         @arguments = []
         @call_configuration = CallConfiguration.new(
           Pathname.new(dir).join("#{command}_stub.yml"),
@@ -37,22 +36,20 @@ module Rspec
         @call_log.call_count(*arg)
       end
 
-      def returns_exitstatus(statuscode)
-        @call_configuration.set_exitcode(statuscode, @arguments)
-        @call_configuration.write
+      def returns_exitstatus(exitcode)
+        @call_configuration.set_exitcode(exitcode, @arguments)
         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
+        @call_configuration.add_output(contents, to, @arguments)
         self
       end
 
+      def stdin
+        @call_log.stdin_for_args(*@arguments) if @call_log.exist?
+      end
+
       def inspect
         if @arguments.any?
           "<Stubbed #{@call_configuration.command.inspect} " \
@@ -64,8 +61,19 @@ module Rspec
 
       private
 
-      def stub_filepath
-        project_root.join('bin', 'stub')
+      def create_stub_file(command_name, directory)
+        command_path = File.join(directory, command_name)
+
+        stub_template_path = File.expand_path(
+          'stub.rb.erb', "#{File.dirname(__FILE__)}/../../../bin"
+        )
+        template = ERB.new File.read(stub_template_path), nil, '%'
+        rspec_bash_library_path_for_template = project_root.join('lib')
+        stub_content = template.result(binding)
+        File.open(command_path, 'w') { |file| file.write(stub_content) }
+        File.chmod(0755, command_path)
+
+        command_path
       end
 
       def project_root

data/lib/rspec/bash/stubbed_env.rb

@@ -16,13 +16,10 @@ module Rspec
 
       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
 
@@ -32,19 +29,21 @@ module Rspec
       end
 
       def execute(command, env_vars = {})
-        full_command = get_wrapped_execution_with_function_overrides(<<-multiline_script
-          #{env} source #{command}
-        multiline_script
+        full_command = get_wrapped_execution_with_function_overrides(
+          <<-multiline_script
+            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
+        full_command = get_wrapped_execution_with_function_overrides(
+          <<-multiline_script
+            source #{script}
+            #{command}
+          multiline_script
         )
 
         Open3.capture3(env_vars, full_command)
@@ -63,7 +62,9 @@ module Rspec
         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_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)
@@ -74,15 +75,13 @@ module Rspec
         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 = 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

data/lib/rspec/bash/util.rb

@@ -0,0 +1,2 @@
+require 'rspec/bash/util/call_log_argument_list_matcher'
+require 'rspec/bash/util/call_conf_argument_list_matcher'

data/lib/rspec/bash/util/call_conf_argument_list_matcher.rb

@@ -0,0 +1,47 @@
+require 'rspec/mocks/argument_list_matcher'
+include RSpec::Mocks
+include RSpec::Mocks::ArgumentMatchers
+
+module Rspec
+  module Bash
+    module Util
+      class CallConfArgumentListMatcher < ArgumentListMatcher
+        alias parent_args_match? args_match?
+        alias parent_initialize initialize
+
+        def initialize(call_conf_list)
+          @expected_call_conf_list = call_conf_list
+        end
+
+        def args_match?(*call_arguments)
+          !get_call_conf_matches(*call_arguments).empty?
+        end
+
+        def get_best_call_conf(*call_arguments)
+          get_call_conf_matches(*call_arguments).sort_by do |call_conf|
+            [
+              call_conf[:args].length
+            ]
+          end.last || {}
+        end
+
+        def get_call_conf_matches(*call_arguments)
+          @expected_call_conf_list.select do |expected_call_conf|
+            @expected_args = remap_argument_matchers(expected_call_conf[:args])
+            parent_args_match?(*call_arguments)
+          end
+        end
+
+        private
+
+        def remap_argument_matchers(expected_call_conf_args)
+          expected_call_conf_args.map! do |expected_arg|
+            next expected_arg unless expected_arg.is_a?(ArgumentMatchers::SingletonMatcher)
+            Object.const_get("#{expected_arg.class}::INSTANCE")
+          end
+          expected_call_conf_args.empty? ? [any_args] : expected_call_conf_args
+        end
+      end
+    end
+  end
+end

data/lib/rspec/bash/util/call_log_argument_list_matcher.rb

@@ -0,0 +1,33 @@
+require 'rspec/mocks/argument_list_matcher'
+include RSpec::Mocks
+include RSpec::Mocks::ArgumentMatchers
+
+module Rspec
+  module Bash
+    module Util
+      class CallLogArgumentListMatcher < ArgumentListMatcher
+        alias parent_args_match? args_match?
+        alias parent_initialize initialize
+
+        def initialize(*expected_args)
+          expected_args = expected_args.empty? ? [any_args] : expected_args
+          parent_initialize(*expected_args)
+        end
+
+        def args_match?(actual_call_log_list)
+          get_call_count(actual_call_log_list) > 0
+        end
+
+        def get_call_count(actual_call_log_list)
+          get_call_log_matches(actual_call_log_list).size
+        end
+
+        def get_call_log_matches(actual_call_log_list)
+          actual_call_log_list.select do |actual_call_list|
+            parent_args_match?(*actual_call_list[:args])
+          end
+        end
+      end
+    end
+  end
+end

data/return_exitstatus_spec.rb

@@ -0,0 +1,14 @@
+require 'English'
+require 'rspec/bash'
+
+describe 'very simple script that just exits' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  it 'returns an exit status of 0' do
+    out, err, rv = stubbed_env.execute_inline('exit 0')
+
+    expect(out).to eql ''
+    expect(err).to eql ''
+    expect(rv.exitstatus).to eql 0
+  end
+end

data/rspec-bash.gemspec

@@ -4,13 +4,12 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'rspec-bash'
-  spec.version       = '0.0.3'
+  spec.version       = '0.1.0'
   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
+    Test Bash scripts through stubbing and mocking Bash commands
   DESCRIPTION
   spec.homepage      = 'https://github.com/mdurban/rspec-bash'
   spec.license       = 'MIT'

data/spec/classes/call_configuration_spec.rb

@@ -1,21 +1,309 @@
-require 'rspec/bash'
+require 'spec_helper'
 
 describe 'CallConfiguration' do
   let(:stubbed_env) { create_stubbed_env }
   include Rspec::Bash
 
+  let(:mock_conf_file) { StringFileIO.new }
+  let(:mock_conf_pathname) { instance_double(Pathname) }
+  before(:each) do
+    allow(mock_conf_pathname).to receive(:open).with('r').and_yield(mock_conf_file)
+    allow(mock_conf_pathname).to receive(:open).with('w').and_yield(mock_conf_file)
+  end
+
   context '#set_exitcode' do
-    it 'returns the status code that is provided' do
-      @subject = Rspec::Bash::CallConfiguration.new(anything, anything)
+    context 'with any setup' do
+      subject { Rspec::Bash::CallConfiguration.new(mock_conf_pathname, 'command_name') }
+
+      context 'with no existing configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 1,
+              outputs: []
+            }
+          ]
+        end
+
+        it 'updates the status code conf for the arguments passed in' do
+          subject.set_exitcode(1, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
+
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.set_exitcode(1, %w(first_argument second_argument))
+        end
+      end
+      context 'with an existing, non-matching configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument),
+              exitcode: 1,
+              outputs: []
+            },
+            {
+
+              args: %w(first_argument second_argument),
+              exitcode: 1,
+              outputs: []
+            }
+          ]
+        end
+        before(:each) do
+          subject.call_configuration = [
+            {
+              args: %w(first_argument),
+              exitcode: 1,
+              outputs: []
+            }
+          ]
+        end
+        it 'updates the status code conf for the arguments passed in' do
+          subject.set_exitcode(1, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
+
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.set_exitcode(1, %w(first_argument second_argument))
+        end
+      end
+      context 'with an existing, matching configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 1,
+              outputs: []
+            }
+          ]
+        end
+        before(:each) do
+          subject.call_configuration = [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 2,
+              outputs: []
+            }
+          ]
+        end
+
+        it 'updates the status code conf for the arguments passed in' do
+          subject.set_exitcode(1, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
+
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.set_exitcode(1, %w(first_argument second_argument))
+        end
+      end
+    end
+    context 'with no config_path' do
+      subject { Rspec::Bash::CallConfiguration.new(nil, anything) }
+      it 'raises an error' do
+        expect do
+          subject.set_exitcode(1, %w(first_argument second_argument))
+        end.to raise_exception(NoMethodError)
+      end
+    end
+  end
+  context '#add_output' do
+    context 'with any setup' do
+      subject { Rspec::Bash::CallConfiguration.new(mock_conf_pathname, 'command_name') }
+
+      context 'with no existing configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 0,
+              outputs: [
+                {
+                  target: :stderr,
+                  content: 'new_content'
+                }
+              ]
+            }
+          ]
+        end
+        it 'updates the outputs for the arguments passed in' do
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
+
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+        end
+      end
+      context 'with an existing, non-matching configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument),
+              exitcode: 1,
+              outputs: [
+                {
+                  target: :stdout,
+                  content: 'different_content'
+                }
+              ]
+            },
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 0,
+              outputs: [
+                {
+                  target: :stderr,
+                  content: 'new_content'
+                }
+              ]
+            }
+          ]
+        end
+        before(:each) do
+          subject.call_configuration = [
+            {
+              args: %w(first_argument),
+              exitcode: 1,
+              outputs: [
+                {
+                  target: :stdout,
+                  content: 'different_content'
+                }
+              ]
+            }
+          ]
+        end
+        it 'updates the outputs conf for the arguments passed in' do
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
+
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+        end
+      end
+      context 'with an existing, matching configuration' do
+        let(:expected_conf) do
+          [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 1,
+              outputs: [
+                {
+                  target: :stdout,
+                  content: 'old_content'
+                },
+                {
+                  target: :stderr,
+                  content: 'new_content'
+                }
+              ]
+            }
+          ]
+        end
+        before(:each) do
+          subject.call_configuration = [
+            {
+              args: %w(first_argument second_argument),
+              exitcode: 1,
+              outputs: [
+                {
+                  target: :stdout,
+                  content: 'old_content'
+                }
+              ]
+            }
+          ]
+        end
+        it 'adds to the outputs conf for the arguments passed in' do
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+          expect(subject.call_configuration).to eql expected_conf
+        end
 
-      expect(@subject.set_exitcode('status')).to eql 'status'
+        it 'writes that configuration to its conf file' do
+          expect(mock_conf_file).to receive(:write).with(expected_conf.to_yaml)
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+        end
+      end
+    end
+    context 'with no config_path' do
+      subject { Rspec::Bash::CallConfiguration.new(nil, anything) }
+      it 'raises an error' do
+        expect do
+          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
+        end.to raise_exception(NoMethodError)
+      end
     end
   end
-  context '#write' do
-      it 'raises error when there is no config_path' do
-      @subject = Rspec::Bash::CallConfiguration.new(nil, anything)
+  context '#call_configuration' do
+    context 'when there is no config_path' do
+      subject { Rspec::Bash::CallConfiguration.new(nil, anything) }
+      it 'returns an empty array' do
+        expect(subject.call_configuration).to eql []
+      end
+    end
+    context 'when the conf file exists but is empty' do
+      subject { Rspec::Bash::CallConfiguration.new(mock_conf_pathname, anything) }
+      before(:each) do
+        allow(mock_conf_file).to receive(:read).and_return('')
+      end
+      it 'returns an empty array' do
+        expect(subject.call_configuration).to eql []
+      end
+    end
+    context 'when the call log file open throws a file not found exception' do
+      subject { Rspec::Bash::CallConfiguration.new(mock_conf_pathname, anything) }
+      before(:each) do
+        allow(mock_conf_pathname).to receive(:open).with('r').and_raise(Errno::ENOENT)
+      end
+      it 'returns an empty array' do
+        expect(subject.call_configuration).to eql []
+      end
+    end
+    context 'when setup is valid' do
+      subject { Rspec::Bash::CallConfiguration.new(mock_conf_pathname, 'command_name') }
+      let(:conf) do
+        [{
+          args: %w(first_argument second_argument),
+          exitcode: 1,
+          outputs: [
+            {
+              target: :stdout,
+              content: 'old_content'
+            },
+            {
+              target: :stderr,
+              content: 'new_content'
+            }
+          ]
+        }]
+      end
+      context 'and no configuration exists' do
+        before(:each) do
+          allow(mock_conf_file).to receive(:read).and_return(conf.to_yaml)
+          allow(mock_conf_pathname).to receive(:open).with('r').and_yield(mock_conf_file)
+        end
+
+        it 'reads out what was in its configuration file' do
+          expect(subject.call_configuration).to eql conf
+        end
+      end
+      context 'and a configuration already exists' do
+        before(:each) do
+          subject.call_configuration = conf
+        end
 
-      expect { @subject.write }.to raise_exception(NoMethodError)
+        it 'reads out what was in its configuration file' do
+          expect(subject.call_configuration).to eql conf
+        end
+      end
     end
   end
 end