rspec-bash 0.0.3 → 0.1.0

data/spec/classes/util/call_log_argument_list_matcher_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+include Rspec::Bash::Util
+
+describe 'CallLogArgumentListMatcher' do
+  context '#get_call_count' do
+    context 'given a call log list with a with multiple sets of arguments' do
+      let(:call_log_list) do
+        [
+          {
+            stdin: 'first_stdin',
+            args: %w(first_argument second_argument)
+          },
+          {
+            stdin: 'second_stdin',
+            args: %w(first_argument second_argument third_argument)
+          },
+          {
+            stdin: 'third_stdin',
+            args: %w(first_argument second_argument)
+          }
+        ]
+      end
+
+      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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        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 no expected argument list' do
+        subject = CallLogArgumentListMatcher.new
+        actual_match_count = subject.get_call_count(call_log_list)
+        expect(actual_match_count).to be 3
+      end
+    end
+  end
+
+  context '#get_call_log_matches' do
+    context 'given a call log list with a with multiple sets of arguments and stdin' do
+      let(:call_log_list) do
+        [
+          {
+            stdin: 'first_stdin',
+            args: %w(first_argument second_argument)
+          },
+          {
+            stdin: 'second_stdin',
+            args: %w(first_argument second_argument third_argument)
+          },
+          {
+            stdin: 'third_stdin',
+            args: %w(first_argument second_argument)
+          }
+        ]
+      end
+
+      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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        matches = subject.get_call_log_matches(call_log_list)
+        expect(matches).to eql []
+      end
+
+      it 'returns the correct call log entries for no expected argument list' do
+        subject = CallLogArgumentListMatcher.new
+        matches = subject.get_call_log_matches(call_log_list)
+        expect(matches).to eql call_log_list
+      end
+    end
+  end
+
+  context '#args_match?' do
+    context 'given a call list with a with multiple sets of arguments' do
+      let(:call_log_list) do
+        [
+          {
+            stdin: 'first_stdin',
+            args: %w(first_argument second_argument)
+          },
+          {
+            stdin: 'second_stdin',
+            args: %w(first_argument second_argument third_argument)
+          },
+          {
+            stdin: 'third_stdin',
+            args: %w(first_argument second_argument)
+          }
+        ]
+      end
+
+      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)
+        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)
+        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)
+        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)
+        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)
+        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)
+        matches = subject.args_match?(call_log_list)
+        expect(matches).to be false
+      end
+
+      it 'returns true for no 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/helper/shared_tmpdir.rb

@@ -0,0 +1,6 @@
+RSpec.shared_examples 'manage a :temp_directory' do
+  let(:temp_directory) { Dir.mktmpdir }
+  after(:each) do
+    FileUtils.remove_entry_secure temp_directory
+  end
+end

data/spec/helper/string_file_io.rb

@@ -0,0 +1,9 @@
+class StringFileIO < StringIO
+  def read
+    string
+  end
+
+  def write(new_string)
+    self.string = new_string
+  end
+end

data/spec/integration/call_log/called_with_args_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'CallLog' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:first_command) { stubbed_env.stub_command('first_command') }
+
+  context '#called_with_args?' do
+    context 'when given multiple command calls' do
+      before(:each) do
+        stubbed_env.execute_inline(
+          <<-multiline_script
+              first_command first_argument second_argument
+              first_command first_argument second_argument third_argument
+        multiline_script
+        )
+      end
+
+      it 'matches for implied anything matches' do
+        expect(first_command).to be_called_with_arguments
+      end
+
+      it 'does not match for non-matches' do
+        expect(first_command).to_not be_called_with_arguments('first_argument')
+      end
+
+      it 'matches for exact matches' do
+        expect(first_command).to be_called_with_arguments('first_argument', 'second_argument')
+      end
+
+      it 'matches for anything matches' do
+        expect(first_command).to be_called_with_arguments(anything, anything, 'third_argument')
+      end
+
+      it 'matches for anyd_args matches' do
+        expect(first_command).to be_called_with_arguments(any_args)
+      end
+
+      it 'matches for other types of RSpec::Mock::ArgumentMatcher matches' do
+        expect(first_command).to be_called_with_arguments(instance_of(String), instance_of(String))
+      end
+
+      it 'matches for regex matches' do
+        expect(first_command).to be_called_with_arguments(/f..st_argument/, /se..nd_argument/)
+      end
+    end
+  end
+end

data/spec/integration/call_log/called_with_no_args_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'CallLog' do
+  context '#called_with_no_args?' do
+    include Rspec::Bash
+    let(:stubbed_env) { create_stubbed_env }
+    let!(:ls) { stubbed_env.stub_command('ls') }
+
+    before do
+      stubbed_env.execute_inline(
+        <<-multiline_script
+          ls
+      multiline_script
+      )
+    end
+
+    it 'is called with no arguments' do
+      expect(ls).to be_called_with_no_arguments
+    end
+  end
+end

data/spec/integration/call_log/stdin_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'CallLog' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:first_command) { stubbed_env.stub_command('first_command') }
+
+  context '#stdin' do
+    context 'when given multiple command calls' do
+      before(:each) do
+        stubbed_env.execute_inline(
+          <<-multiline_script
+              echo -n 'first_call' | first_command first_argument second_argument
+              echo -n 'second_call' | first_command first_argument second_argument third_argument
+        multiline_script
+        )
+      end
+
+      it 'matches for implied anything matches' do
+        expect(first_command.stdin).to eql 'first_call'
+      end
+
+      it 'does not match for non-matches' do
+        expect(first_command.with_args('first_argument').stdin).to be nil
+      end
+
+      it 'matches for exact matches' do
+        expect(first_command
+          .with_args('first_argument', 'second_argument').stdin).to eql 'first_call'
+      end
+
+      it 'matches for anything matches' do
+        expect(first_command
+          .with_args(anything, anything, 'third_argument').stdin).to eql 'second_call'
+      end
+
+      it 'matches for any_args matches' do
+        expect(first_command
+          .with_args(any_args).stdin).to eql 'first_call'
+      end
+
+      it 'matches for other types of RSpec::Mock::ArgumentMatcher matches' do
+        expect(first_command
+          .with_args(instance_of(String), instance_of(String)).stdin).to eql 'first_call'
+      end
+
+      it 'matches for regex matches' do
+        expect(first_command
+          .with_args(/f..st_argument/, /se..nd_argument/, /.*/).stdin).to eql 'second_call'
+      end
+    end
+  end
+end

data/spec/integration/matchers/be_called_with_arguments_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'RSpec::Matchers' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+
+  context '.be_called_with_arguments' do
+    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
+end

data/spec/integration/matchers/be_called_with_no_arguments_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'RSpec::Matchers' do
+  include Rspec::Bash
+  let(:stubbed_env) { create_stubbed_env }
+
+  context '.be_called_with_no_arguments' do
+    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
+end