rspec-bash 0.0.3 → 0.1.0

data/spec/classes/stubbed_command_spec.rb

@@ -1,9 +1,9 @@
-require 'English'
-require 'rspec/bash'
+require 'spec_helper'
+include Rspec::Bash
 
 describe 'StubbedCommand' do
-  include Rspec::Bash
-  let(:stubbed_env) { create_stubbed_env }
+  include_examples 'manage a :temp_directory'
+
   before(:each) do
     allow(FileUtils).to receive(:cp)
   end
@@ -12,11 +12,13 @@ describe 'StubbedCommand' do
     before(:each) do
       @call_log = double(Rspec::Bash::CallLog)
       allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     context 'with only a series of arguments' do
       it 'passes the check to its CallLog\'s #called_with_args? method' do
-        expect(@call_log).to receive(:called_with_args?).with('first_argument', 'second_argument').and_return(true)
+        expect(@call_log).to receive(:called_with_args?)
+          .with('first_argument', 'second_argument')
+          .and_return(true)
         @subject.called_with_args?('first_argument', 'second_argument')
       end
     end
@@ -24,7 +26,7 @@ describe 'StubbedCommand' do
 
   context '#with_args' do
     before(:each) do
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
       @subject.with_args('argument_one', 'argument_two')
     end
     it 'sets the arguments array on the StubbedCommand to the arguments that were passed in' do
@@ -36,19 +38,22 @@ describe 'StubbedCommand' do
     before(:each) do
       @call_log = double(Rspec::Bash::CallLog)
       allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     it 'returns value returned from call_log argument count when there are no arguments' do
       expect(@call_log).to receive(:call_count).with([]).and_return('arbitrary return value')
       expect(@subject.call_count([])).to eql 'arbitrary return value'
     end
     it 'returns value returned from call_log argument count when there is only one argument' do
-      expect(@call_log).to receive(:call_count).with(['only arg']).and_return('arbitrary return value')
-      expect(@subject.call_count ['only arg']).to eql 'arbitrary return value'
+      expect(@call_log).to receive(:call_count)
+        .with(['only arg'])
+        .and_return('arbitrary return value')
+      expect(@subject.call_count(['only arg'])).to eql 'arbitrary return value'
     end
     it 'returns value returned from call_log argument count when there are multiple  arguments' do
-      expect(@call_log).to receive(:call_count).with(['first arg', 'second arg']).and_return('arbitrary return value')
-      expect(@subject.call_count ['first arg', 'second arg']).to eql 'arbitrary return value'
+      expect(@call_log).to receive(:call_count).with(['first arg', 'second arg'])
+        .and_return('arbitrary return value')
+      expect(@subject.call_count(['first arg', 'second arg'])).to eql 'arbitrary return value'
     end
   end
 
@@ -56,7 +61,7 @@ describe 'StubbedCommand' do
     before(:each) do
       @call_log = double(Rspec::Bash::CallLog)
       allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     it 'returns false when there is no call_log' do
       expect(@call_log).to receive(:exist?).and_return(false)
@@ -73,12 +78,12 @@ describe 'StubbedCommand' do
       expect(@subject.called?).to be_truthy
     end
   end
-  
+
   context '#stdin' do
     before(:each) do
       @call_log = double(Rspec::Bash::CallLog)
       allow(Rspec::Bash::CallLog).to receive(:new).and_return(@call_log)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     it 'returns nil when there is no call_log' do
       expect(@call_log).to receive(:exist?).and_return(false)
@@ -95,39 +100,34 @@ describe 'StubbedCommand' do
     before(:each) do
       @call_configuration = double(Rspec::Bash::CallConfiguration)
       allow(Rspec::Bash::CallConfiguration).to receive(:new).and_return(@call_configuration)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     it 'sets the exitcode on call_configuration' do
       expect(@call_configuration).to receive(:set_exitcode).with('exit code', anything)
-      expect(@call_configuration).to receive(:write)
       @subject.returns_exitstatus 'exit code'
     end
     it 'returns itself' do
       expect(@call_configuration).to receive(:set_exitcode)
-      expect(@call_configuration).to receive(:write)
       expect(@subject.returns_exitstatus(anything)).to eql @subject
     end
   end
-  
+
   context '#outputs' do
     before(:each) do
       @call_configuration = double(Rspec::Bash::CallConfiguration)
       allow(Rspec::Bash::CallConfiguration).to receive(:new).and_return(@call_configuration)
-      @subject = Rspec::Bash::StubbedCommand.new('command', Dir.mktmpdir)
+      @subject = Rspec::Bash::StubbedCommand.new('command', temp_directory)
     end
     it 'sets the output on the call_configuration' do
-      expect(@call_configuration).to receive(:set_output).with('contents', 'stderr', anything)
-      expect(@call_configuration).to receive(:write)
+      expect(@call_configuration).to receive(:add_output).with('contents', 'stderr', anything)
       @subject.outputs('contents', to: 'stderr')
     end
     it 'sets the "to" value for the output to stdout by default' do
-      expect(@call_configuration).to receive(:set_output).with('contents', :stdout, anything)
-      expect(@call_configuration).to receive(:write)
+      expect(@call_configuration).to receive(:add_output).with('contents', :stdout, anything)
       @subject.outputs('contents')
     end
     it 'returns itself' do
-      expect(@call_configuration).to receive(:set_output)
-      expect(@call_configuration).to receive(:write)
+      expect(@call_configuration).to receive(:add_output)
       expect(@subject.outputs(anything)).to eql @subject
     end
   end

data/spec/classes/stubbed_env_spec.rb

@@ -1,5 +1,4 @@
-require 'English'
-require 'rspec/bash'
+require 'spec_helper'
 
 describe 'StubbedEnv' do
   include Rspec::Bash
@@ -15,15 +14,16 @@ describe 'StubbedEnv' do
 
       context 'and no arguments' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-            #!/usr/bin/env bash
-            function overridden_function {
-              echo 'i was not overridden'
-            }
-            overridden_function
-
-            echo 'standard error output' 1>&2
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+              #!/usr/bin/env bash
+              function overridden_function {
+                echo 'i was not overridden'
+              }
+              overridden_function
+
+              echo 'standard error output' 1>&2
+            multiline_script
           )
         end
 
@@ -42,15 +42,16 @@ describe 'StubbedEnv' do
 
       context 'and simple arguments' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-          #!/usr/bin/env bash
-            function overridden_function {
-              echo 'i was not overridden'
-            }
-            overridden_function argument_one argument_two
-
-            echo 'standard error output' 1>&2
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+            #!/usr/bin/env bash
+              function overridden_function {
+                echo 'i was not overridden'
+              }
+              overridden_function argument_one argument_two
+
+              echo 'standard error output' 1>&2
+            multiline_script
           )
         end
 
@@ -65,15 +66,16 @@ describe 'StubbedEnv' do
 
       context 'and complex arguments (spaces, etc.)' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-          #!/usr/bin/env bash
-            function overridden_function {
-              echo 'i was not overridden'
-            }
-            overridden_function "argument one" "argument two"
-
-            echo 'standard error output' 1>&2
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+            #!/usr/bin/env bash
+              function overridden_function {
+                echo 'i was not overridden'
+              }
+              overridden_function "argument one" "argument two"
+
+              echo 'standard error output' 1>&2
+            multiline_script
           )
         end
 
@@ -95,10 +97,11 @@ describe 'StubbedEnv' do
 
       context 'and no arguments' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-            #!/usr/bin/env bash
-            overridden_command
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command
+            multiline_script
           )
         end
 
@@ -113,10 +116,11 @@ describe 'StubbedEnv' do
 
       context 'and simple arguments' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-            #!/usr/bin/env bash
-            overridden_command argument_one argument_two
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command argument_one argument_two
+            multiline_script
           )
         end
 
@@ -131,10 +135,11 @@ describe 'StubbedEnv' do
 
       context 'and complex arguments (spaces, etc.)' do
         before(:each) do
-          @stdout, @stderr, @status = subject.execute_inline(<<-multiline_script
-            #!/usr/bin/env bash
-            overridden_command "argument one" "argument two"
-          multiline_script
+          @stdout, @stderr, @status = subject.execute_inline(
+            <<-multiline_script
+              #!/usr/bin/env bash
+              overridden_command "argument one" "argument two"
+            multiline_script
           )
         end
 
@@ -161,8 +166,8 @@ describe 'StubbedEnv' do
       context 'and no arguments' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_function'
+            './spec/scripts/function_library.sh',
+            'overridden_function'
           )
         end
 
@@ -182,8 +187,8 @@ describe 'StubbedEnv' do
       context 'and simple arguments' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_function argument_one argument_two'
+            './spec/scripts/function_library.sh',
+            'overridden_function argument_one argument_two'
           )
         end
 
@@ -199,8 +204,8 @@ describe 'StubbedEnv' do
       context 'and complex arguments (spaces, etc.)' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_function "argument one" "argument two"'
+            './spec/scripts/function_library.sh',
+            'overridden_function "argument one" "argument two"'
           )
         end
 
@@ -223,8 +228,8 @@ describe 'StubbedEnv' do
       context 'and no arguments' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_command_function'
+            './spec/scripts/function_library.sh',
+            'overridden_command_function'
           )
         end
 
@@ -244,8 +249,8 @@ describe 'StubbedEnv' do
       context 'and simple arguments' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_command_function argument_one argument_two'
+            './spec/scripts/function_library.sh',
+            'overridden_command_function argument_one argument_two'
           )
         end
 
@@ -261,8 +266,8 @@ describe 'StubbedEnv' do
       context 'and complex arguments (spaces, etc.)' do
         before(:each) do
           @stdout, @stderr, @status = subject.execute_function(
-              './spec/scripts/function_library.sh',
-              'overridden_command_function "argument one" "argument two"'
+            './spec/scripts/function_library.sh',
+            'overridden_command_function "argument one" "argument two"'
           )
         end
 
@@ -278,10 +283,6 @@ describe 'StubbedEnv' do
   end
 
   describe 'creating a stubbed env' do
-    it 'extends the PATH with the stubbed folder first' do
-      expect { create_stubbed_env }.to change { ENV['PATH'] }
-    end
-
     it 'creates a folder to place the stubbed commands in' do
       env = create_stubbed_env
       expect(Pathname.new(env.dir)).to exist
@@ -290,13 +291,6 @@ describe 'StubbedEnv' do
   end
 
   describe '#cleanup' do
-    it 'restores the environment variable PATH' do
-      original_path = ENV['PATH']
-      env = create_stubbed_env
-
-      expect { env.cleanup }.to change { ENV['PATH'] }.to original_path
-    end
-
     it 'removes the folder with stubbed commands' do
       env = create_stubbed_env
       env.cleanup

data/spec/classes/util/call_conf_argument_list_matcher_spec.rb

@@ -0,0 +1,579 @@
+require 'spec_helper'
+include Rspec::Bash::Util
+
+describe 'CallConfArgumentListMatcher' do
+  context '#get_best_call_conf' do
+    context 'given a call conf list with a with multiple sets of args, output and exitcodes' do
+      let(:call_conf_list) do
+        [
+          {
+            args: [],
+            exitcode: 6,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'seventh_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument third_argument),
+            exitcode: 1,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'second_content'
+              }
+            ]
+          },
+          {
+            args: ['first_argument', anything, anything],
+            exitcode: 3,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fourth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, 'second_argument'],
+            exitcode: 4,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fifth_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 0,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'first_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 2,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'third_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything],
+            exitcode: 5,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'sixth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, 'third_argument', anything, anything],
+            exitcode: 7,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'eighth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything, anything],
+            exitcode: 8,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'ninth_content'
+              }
+            ]
+          },
+          {
+            args: [anything],
+            exitcode: 9,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'tenth_content'
+              }
+            ]
+          },
+          {
+            args: [anything],
+            exitcode: 10,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'eleventh_content'
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns the longest conf match' do
+        argument_list_from_call = %w(first_argument second_argument third_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to eql call_conf_list.at(2)
+      end
+
+      it 'returns the last longest conf match for multiple exact matches' do
+        argument_list_from_call = %w(first_argument second_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to eql call_conf_list.at(5)
+      end
+
+      it 'returns the longest conf match for any_arg v. anything matches' do
+        argument_list_from_call = %w(first_argument second_argument third_argument fourth_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to eql call_conf_list.at(6)
+      end
+
+      it 'returns the last longest conf match for matches with some anythings' do
+        argument_list_from_call = %w(
+          first_argument second_argument third_argument
+          fourth_argument fifth_argument
+        )
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to eql call_conf_list.at(8)
+      end
+
+      it 'returns the last anything match for multiple, all anything matches' do
+        argument_list_from_call = %w(first_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to eql call_conf_list.at(10)
+      end
+    end
+    context 'given a call conf list with a with no all matchers' do
+      let(:call_conf_list) do
+        [
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 0,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'first_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument third_argument),
+            exitcode: 1,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'second_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 2,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'third_content'
+              }
+            ]
+          },
+          {
+            args: ['first_argument', anything, 'third_argument'],
+            exitcode: 3,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fourth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, 'second_argument'],
+            exitcode: 4,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fifth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything],
+            exitcode: 5,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'sixth_content'
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns an empty conf for no matches' do
+        argument_list_from_call =
+          %w(first_argument second_argument third_argument fourth_argument fifth_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match = subject.get_best_call_conf(*argument_list_from_call)
+        expect(call_conf_match).to be_empty
+      end
+    end
+  end
+  context '#get_call_conf_matches' do
+    context 'given a call conf list with a with multiple sets of args, output and exitcodes' do
+      let(:call_conf_list) do
+        [
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 0,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'first_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument third_argument),
+            exitcode: 1,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'second_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 2,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'third_content'
+              }
+            ]
+          },
+          {
+            args: ['first_argument', YAML.load(YAML.dump(anything)), 'third_argument'],
+            exitcode: 3,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fourth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, 'second_argument'],
+            exitcode: 4,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fifth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything],
+            exitcode: 5,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'sixth_content'
+              }
+            ]
+          },
+          {
+            args: [],
+            exitcode: 6,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'seventh_content'
+              }
+            ]
+          },
+          {
+            args: [
+              'first_argument', 'second_argument',
+              'third_argument', 'fourth_argument', any_args
+            ],
+            exitcode: 6,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'seventh_content'
+              }
+            ]
+          },
+          {
+            args: [
+              'first_argument', 'second_argument',
+              'third_argument', 'fourth_argument', YAML.load(YAML.dump(any_args))
+            ],
+            exitcode: 6,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'seventh_content'
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns the correct confs for a single exact/anything argument match' do
+        argument_list_from_call = %w(first_argument second_argument third_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match_list = subject.get_call_conf_matches(*argument_list_from_call)
+        expect(call_conf_match_list).to eql call_conf_list.values_at(1, 3, 6)
+      end
+
+      it 'returns the correct confs for multiple exact/anything argument matches' do
+        argument_list_from_call = %w(first_argument second_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match_list = subject.get_call_conf_matches(*argument_list_from_call)
+        expect(call_conf_match_list).to eql call_conf_list.values_at(0, 2, 4, 6)
+      end
+
+      it 'returns the correct confs for the all argument match' do
+        argument_list_from_call = %w(first_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        call_conf_match_list = subject.get_call_conf_matches(*argument_list_from_call)
+        expect(call_conf_match_list).to eql call_conf_list.values_at(6)
+      end
+
+      it 'returns the correct confs for an any_args match' do
+        argument_list_from_call = %w(
+          first_argument second_argument
+          third_argument fourth_argument fifth_argument
+        )
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.get_call_conf_matches(*argument_list_from_call)
+        expect(actual_args_match).to eql call_conf_list.values_at(6, 7, 8)
+      end
+    end
+  end
+  context '#args_match?' do
+    context 'given a call conf list with a with multiple sets of args, output and exitcodes' do
+      let(:call_conf_list) do
+        [
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 0,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'first_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument third_argument),
+            exitcode: 1,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'second_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 2,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'third_content'
+              }
+            ]
+          },
+          {
+            args: ['first_argument', anything, 'third_argument'],
+            exitcode: 3,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fourth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, 'second_argument'],
+            exitcode: 4,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fifth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything],
+            exitcode: 5,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'sixth_content'
+              }
+            ]
+          },
+          {
+            args: [],
+            exitcode: 7,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'eighth_content'
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns the correct confs for a single exact/anything argument match' do
+        argument_list_from_call = %w(first_argument second_argument third_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+
+      it 'returns the correct confs for multiple exact/anything argument matches' do
+        argument_list_from_call = %w(first_argument second_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+
+      it 'returns the correct confs for the all argument match' do
+        argument_list_from_call = %w(first_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+    end
+    context 'given a call conf list with a with no all matchers' do
+      let(:call_conf_list) do
+        [
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 0,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'first_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument third_argument),
+            exitcode: 1,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'second_content'
+              }
+            ]
+          },
+          {
+            args: %w(first_argument second_argument),
+            exitcode: 2,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'third_content'
+              }
+            ]
+          },
+          {
+            args: ['first_argument', anything, 'third_argument'],
+            exitcode: 3,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fourth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, 'second_argument'],
+            exitcode: 4,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'fifth_content'
+              }
+            ]
+          },
+          {
+            args: [anything, anything, anything, anything],
+            exitcode: 5,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'sixth_content'
+              }
+            ]
+          },
+          {
+            args: [
+              'first_argument', 'second_argument',
+              'third_argument', 'fourth_argument', any_args
+            ],
+            exitcode: 6,
+            outputs: [
+              {
+                target: :stdout,
+                content: 'seventh_content'
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns the correct confs for a single exact/anything argument match' do
+        argument_list_from_call = %w(first_argument second_argument third_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+
+      it 'returns the correct confs for multiple exact/anything argument matches' do
+        argument_list_from_call = %w(first_argument second_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+
+      it 'returns the correct confs for the all argument match' do
+        argument_list_from_call = %w(first_argument)
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be false
+      end
+
+      it 'returns the correct confs for an any_args match' do
+        argument_list_from_call = %w(
+          first_argument second_argument
+          third_argument fourth_argument fifth_argument
+        )
+        subject = CallConfArgumentListMatcher.new(call_conf_list)
+        actual_args_match = subject.args_match?(*argument_list_from_call)
+        expect(actual_args_match).to be true
+      end
+    end
+  end
+end