rspec-bash 0.1.1 → 0.2.0

data/spec/classes/util/call_log_argument_list_matcher_spec.rb

@@ -23,42 +23,42 @@ describe 'CallLogArgumentListMatcher' do
 
       it 'returns the correct count for a single exact argument match' do
         argument_list_to_match = %w(first_argument second_argument third_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 1
       end
 
       it 'returns the correct count for multiple exact argument matches' do
         argument_list_to_match = %w(first_argument second_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 2
       end
 
       it 'returns the correct count for no argument matches' do
         argument_list_to_match = %w(first_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 0
       end
 
       it 'returns the correct count for a single "anything" match' do
         argument_list_to_match = ['first_argument', anything, 'third_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 1
       end
 
       it 'returns the correct count for multiple "anything" matches' do
         argument_list_to_match = [anything, 'second_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 2
       end
 
       it 'returns the correct count for "anything" matches that are not the exact count' do
         argument_list_to_match = [anything, anything, anything, anything]
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         actual_match_count = subject.get_call_count(call_log_list)
         expect(actual_match_count).to be 0
       end
@@ -92,42 +92,42 @@ describe 'CallLogArgumentListMatcher' do
 
       it 'returns the correct call log entries for a single exact argument match' do
         argument_list_to_match = %w(first_argument second_argument third_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql call_log_list.values_at(1)
       end
 
       it 'returns the correct call log entries for multiple exact argument matches' do
         argument_list_to_match = %w(first_argument second_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql call_log_list.values_at(0, 2)
       end
 
       it 'returns the correct call log entries for no argument matches' do
         argument_list_to_match = %w(first_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql []
       end
 
       it 'returns the correct call log entries for a single "anything" match' do
         argument_list_to_match = ['first_argument', anything, 'third_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql call_log_list.values_at(1)
       end
 
       it 'returns the correct call log entries for multiple "anything" matches' do
         argument_list_to_match = [anything, 'second_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql call_log_list.values_at(0, 2)
       end
 
       it 'returns the correct call log entries for "anything" matches not matching count' do
         argument_list_to_match = [anything, anything, anything, anything]
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.get_call_log_matches(call_log_list)
         expect(matches).to eql []
       end
@@ -161,42 +161,42 @@ describe 'CallLogArgumentListMatcher' do
 
       it 'returns true for a single exact argument match' do
         argument_list_to_match = %w(first_argument second_argument third_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be true
       end
 
       it 'returns true for multiple exact argument matches' do
         argument_list_to_match = %w(first_argument second_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be true
       end
 
       it 'returns false for no argument matches' do
         argument_list_to_match = %w(first_argument)
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be false
       end
 
       it 'returns true for a single "anything" match' do
         argument_list_to_match = ['first_argument', anything, 'third_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be true
       end
 
       it 'returns true for multiple "anything" matches' do
         argument_list_to_match = [anything, 'second_argument']
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be true
       end
 
       it 'returns false for "anything" matches that are not the exact count' do
         argument_list_to_match = [anything, anything, anything, anything]
-        subject = CallLogArgumentListMatcher.new(*argument_list_to_match)
+        subject = CallLogArgumentListMatcher.new(argument_list_to_match)
         matches = subject.args_match?(call_log_list)
         expect(matches).to be false
       end
@@ -206,6 +206,12 @@ describe 'CallLogArgumentListMatcher' do
         matches = subject.args_match?(call_log_list)
         expect(matches).to be true
       end
+
+      it 'returns true for an empty expected argument list' do
+        subject = CallLogArgumentListMatcher.new([])
+        matches = subject.args_match?(call_log_list)
+        expect(matches).to be true
+      end
     end
   end
 end

data/spec/classes/wrapper/bash_wrapper_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'BashWrapper' do
+  let(:server_port) { 4000 }
+  subject { BashWrapper.new(server_port) }
+
+  context '#wrap_script' do
+    let(:script) do
+      'echo hello world'
+    end
+    it 'creates a new script that wraps the passed in one' do
+      wrapped_script = subject.wrap_script(script)
+      expect(wrapped_script).to eql File.join(Dir.tmpdir, "wrapper-#{server_port}.sh")
+    end
+  end
+  context '#cleanup' do
+    it 'cleans up its wrapper and stderr files' do
+      existing_file = double(File)
+      allow(existing_file).to receive(:exist?)
+        .and_return true
+      allow(Pathname).to receive(:new)
+        .with(File.join(Dir.tmpdir, "wrapper-#{server_port}.sh"))
+        .and_return(existing_file)
+      allow(Pathname).to receive(:new)
+        .with(File.join(Dir.tmpdir, "stderr-#{server_port}.tmp"))
+        .and_return(existing_file)
+
+      expect(FileUtils).to receive(:remove_entry_secure)
+        .with(File.join(Dir.tmpdir, "wrapper-#{server_port}.sh"))
+      expect(FileUtils).to receive(:remove_entry_secure)
+        .with(File.join(Dir.tmpdir, "stderr-#{server_port}.tmp"))
+
+      subject.cleanup
+    end
+  end
+end

data/spec/classes/wrapper/ruby_stub_script_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'RubyStubFunction' do
+  let(:subject_path) { RubyStubScript.path }
+
+  let(:stub_output_string_pathname) { instance_double(Pathname) }
+  let(:stub_output_string_file) { StringIO.new }
+  let(:stub_stderr_file) { StringIO.new }
+  let(:stub_stdout_file) { StringIO.new }
+  let(:stub_exit_code_list) { [] }
+
+  let(:stub_socket) { StringFileIO.new }
+
+  def safe_load_subject
+    load subject_path
+  rescue SystemExit
+  end
+
+  before(:each) do
+    $stderr = stub_stderr_file
+    $stdout = stub_stdout_file
+    allow($stdin).to receive(:tty?).and_return(false)
+
+    allow_any_instance_of(Kernel).to receive(:exit) do |_, exit_code|
+      stub_exit_code_list << exit_code
+      raise SystemExit
+    end
+
+    allow(stub_socket).to receive(:close_write)
+    allow(stub_socket).to receive(:close_read)
+    allow(TCPSocket).to receive(:new).and_return(stub_socket)
+    allow(Pathname).to receive(:new).with('tofile')
+      .and_return(stub_output_string_pathname)
+    allow(stub_output_string_pathname).to receive(:open).with('w')
+      .and_yield(stub_output_string_file)
+  end
+
+  context 'with no configuration (logging only)' do
+    let!(:call_log_list) { [] }
+    before do
+      allow(stub_socket).to receive(:read).and_return(Marshal.dump({}))
+      expect(TCPSocket).to receive(:new).exactly(4)
+        .with('localhost', 55_555)
+        .and_return(stub_socket)
+
+      ARGV.replace ['first_command', 55_555]
+      allow($stdin).to receive(:read).and_return('')
+      safe_load_subject
+      call_log_list << Marshal.load(stub_socket.string)
+
+      ARGV.replace ['first_command', 55_555]
+      allow($stdin).to receive(:read).and_return("dog\ncat\n")
+      safe_load_subject
+      call_log_list << Marshal.load(stub_socket.string)
+
+      ARGV.replace ['first_command', 55_555, 'first_argument', 'second_argument']
+      allow($stdin).to receive(:read).and_return('')
+      safe_load_subject
+      call_log_list << Marshal.load(stub_socket.string)
+
+      ARGV.replace ['first_command', 55_555, 'first_argument', 'second_argument']
+      allow($stdin).to receive(:read).and_return("dog\ncat\n")
+      safe_load_subject
+      call_log_list << Marshal.load(stub_socket.string)
+    end
+
+    it 'logs the correct command for the first call' do
+      expect(call_log_list[0][:command]).to eql 'first_command'
+    end
+
+    it 'logs a blank STDIN for the first call' do
+      expect(call_log_list[0][:stdin]).to eql ''
+    end
+
+    it 'logs no arguments for the first call' do
+      expect(call_log_list[0][:args]).to be_empty
+    end
+
+    it 'logs the correct command for the second call' do
+      expect(call_log_list[1][:command]).to eql 'first_command'
+    end
+
+    it 'logs some STDIN for the second call' do
+      expect(call_log_list[1][:stdin]).to eql "dog\ncat\n"
+    end
+
+    it 'logs no arguments for the second call' do
+      expect(call_log_list[1][:args]).to be_empty
+    end
+
+    it 'logs the correct command for the third call' do
+      expect(call_log_list[2][:command]).to eql 'first_command'
+    end
+
+    it 'logs a blank STDIN for the third call' do
+      expect(call_log_list[2][:stdin]).to be_empty
+    end
+
+    it 'logs some arguments for the third call' do
+      expect(call_log_list[2][:args]).to eql %w(first_argument second_argument)
+    end
+
+    it 'logs the correct command for the fourth call' do
+      expect(call_log_list[3][:command]).to eql 'first_command'
+    end
+
+    it 'logs some STDIN for the fourth call' do
+      expect(call_log_list[3][:stdin]).to eql "dog\ncat\n"
+    end
+
+    it 'logs some arguments for the fourth call' do
+      expect(call_log_list[3][:args]).to eql %w(first_argument second_argument)
+    end
+
+    it 'exits with appropriate code for first call' do
+      expect(stub_exit_code_list[0]).to eql 0
+    end
+
+    it 'exits with appropriate code for second call' do
+      expect(stub_exit_code_list[1]).to eql 0
+    end
+
+    it 'exits with appropriate code for third call' do
+      expect(stub_exit_code_list[2]).to eql 0
+    end
+
+    it 'exits with appropriate code for fourth call' do
+      expect(stub_exit_code_list[3]).to eql 0
+    end
+  end
+  context 'with some configuration (logging and output)' do
+    before do
+      stdout_configuration = {
+        args: [],
+        outputs: [
+          {
+            target: :stderr,
+            content: "stderr\n"
+          },
+          {
+            target: :stdout,
+            content: "stdout\n"
+          },
+          {
+            target: 'tofile',
+            content: "tofile\n"
+          }
+        ],
+        exitcode: 8
+      }
+      allow(stub_socket).to receive(:read).and_return(Marshal.dump(stdout_configuration))
+      allow($stdin).to receive(:read).and_return('')
+
+      ARGV.replace ['first_command', 55_555]
+      safe_load_subject
+
+      ARGV.replace ['first_command', 55_555, 'first_argument', 'second_argument']
+      safe_load_subject
+
+      ARGV.replace ['first_command', 55_555, 'first_argument', 'second_argument', 'third_argument']
+      safe_load_subject
+
+      ARGV.replace [
+        'first_command',
+        55_555,
+        'first_argument',
+        'second_argument',
+        'third_argument',
+        'fourth_argument'
+      ]
+
+      safe_load_subject
+    end
+
+    it 'prints the expected output to stderr' do
+      expect(stub_stderr_file.string).to eql "stderr\nstderr\nstderr\nstderr\n"
+    end
+
+    it 'prints the expected output to stdout' do
+      expect(stub_stdout_file.string).to eql "stdout\nstdout\nstdout\nstdout\n"
+    end
+
+    it 'prints the expected output to the string named file' do
+      expect(stub_output_string_file.string).to eql "tofile\ntofile\ntofile\ntofile\n"
+    end
+
+    it 'exits with appropriate code for first call' do
+      expect(stub_exit_code_list[0]).to eql 8
+    end
+
+    it 'exits with appropriate code for second call' do
+      expect(stub_exit_code_list[1]).to eql 8
+    end
+
+    it 'exits with appropriate code for third call' do
+      expect(stub_exit_code_list[2]).to eql 8
+    end
+
+    it 'exits with appropriate code for fourth call' do
+      expect(stub_exit_code_list[3]).to eql 8
+    end
+  end
+end

data/spec/helper/string_file_io.rb

@@ -1,5 +1,5 @@
 class StringFileIO < StringIO
-  def read
+  def read(_length = 0)
     string
   end
 

data/spec/integration/call_log/called_with_args_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
+include Rspec::Bash
 
 describe 'CallLog' do
-  include Rspec::Bash
   let(:stubbed_env) { create_stubbed_env }
   let!(:first_command) { stubbed_env.stub_command('first_command') }
 
@@ -10,7 +10,7 @@ describe 'CallLog' do
       before(:each) do
         stubbed_env.execute_inline(
           <<-multiline_script
-              first_command first_argument second_argument
+              first_command first_argument '\nsecond_argument\n'
               first_command first_argument second_argument third_argument
         multiline_script
         )
@@ -25,7 +25,7 @@ describe 'CallLog' do
       end
 
       it 'matches for exact matches' do
-        expect(first_command).to be_called_with_arguments('first_argument', 'second_argument')
+        expect(first_command).to be_called_with_arguments('first_argument', "\nsecond_argument\n")
       end
 
       it 'matches for anything matches' do
@@ -44,6 +44,7 @@ describe 'CallLog' do
         expect(first_command).to be_called_with_arguments(/f..st_argument/, /se..nd_argument/)
       end
 
+      # rubocop:disable TrailingWhitespace
       it 'displays the diff between what was called and what was expected' do
         begin
           expect(first_command).to be_called_with_arguments('not_first_argument', 'second_argument')
@@ -55,12 +56,15 @@ Expected Calls:
 first_command not_first_argument second_argument
 
 Actual Calls:
-first_command first_argument second_argument
+first_command first_argument 
+second_argument
+
 first_command first_argument second_argument third_argument
           multiline_string
           expect(rex.message).to eql expected_error_string
         end
       end
+      # rubocop:enable TrailingWhitespace
       it 'displays the diff between what was called and what was not expected' do
         begin
           expect(first_command).to_not be_called_with_arguments('first_argument', 'second_argument')