rspec-bash 0.1.1 → 0.2.0

data/spec/integration/call_log/called_with_no_args_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
+include Rspec::Bash
 
 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') }
 

data/spec/integration/call_log/stdin_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') }
 
@@ -11,7 +11,8 @@ describe 'CallLog' 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
+              echo -e '\nsecond_call' | first_command first_argument second_argument third_argument
+              first_command first_argument second_argument third_argument fourth_argument
         multiline_script
         )
       end
@@ -31,7 +32,12 @@ describe 'CallLog' do
 
       it 'matches for anything matches' do
         expect(first_command
-          .with_args(anything, anything, 'third_argument').stdin).to eql 'second_call'
+          .with_args(anything, anything, 'third_argument').stdin).to eql "\nsecond_call\n"
+      end
+
+      it 'is blank for cases where no stdin was passed' do
+        expect(first_command
+          .with_args(anything, anything, 'third_argument', 'fourth_argument').stdin).to be_empty
       end
 
       it 'matches for any_args matches' do
@@ -46,7 +52,7 @@ describe 'CallLog' do
 
       it 'matches for regex matches' do
         expect(first_command
-          .with_args(/f..st_argument/, /se..nd_argument/, /.*/).stdin).to eql 'second_call'
+          .with_args(/f..st_argument/, /se..nd_argument/, /.*/).stdin).to eql "\nsecond_call\n"
       end
     end
   end

data/spec/integration/edge_cases_spec.rb

@@ -0,0 +1,34 @@
+require 'rspec/bash'
+include Rspec::Bash
+
+describe 'scenarios where performance improvements break things' do
+  let(:stubbed_env) { create_stubbed_env }
+
+  context 'weird case where a docker flag argument gets removed' do
+    let!(:docker) { stubbed_env.stub_command('docker') }
+    before do
+      stubbed_env.execute_inline(
+        <<-multiline_script
+          docker run \
+            --rm \
+            -i \
+            --env HADOOP_USER_NAME \
+            --env CLIENT_CONF_URL \
+            xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
+            hadoop fs -test -e  hdfs:///xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        multiline_script
+      )
+    end
+    it 'should not remove the -e flag from the command log' do
+      expect(docker).to be_called_with_arguments(
+        'run',
+        '--rm',
+        '-i',
+        '--env', 'HADOOP_USER_NAME',
+        '--env', 'CLIENT_CONF_URL',
+        'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
+        'hadoop', 'fs', '-test', '-e', 'hdfs:///xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+      )
+    end
+  end
+end

data/spec/integration/matchers/be_called_with_arguments_spec.rb

@@ -1,37 +1,36 @@
 require 'spec_helper'
+include Rspec::Bash
 
 describe 'RSpec::Matchers' do
-  include Rspec::Bash
   let(:stubbed_env) { create_stubbed_env }
 
   context '.be_called_with_arguments' do
     context 'with a command' do
+      let!(:command) { stubbed_env.stub_command('stubbed_command') }
       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(
+          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')
+          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')
+          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)
+          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)
+          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(
+          stubbed_env.execute_inline(
             <<-multiline_script
             stubbed_command duplicated_argument once_called_argument
             stubbed_command duplicated_argument irrelevant_argument
@@ -39,19 +38,19 @@ describe 'RSpec::Matchers' do
           )
         end
         it 'matches when arguments are called twice' do
-          expect(@command)
+          expect(command)
             .to be_called_with_arguments('duplicated_argument', anything).times(2)
         end
         it 'matches when argument is called once' do
-          expect(@command)
+          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)
+          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)
+          expect(command)
             .to_not be_called_with_arguments('not_called_argument').times(1)
         end
       end

data/spec/integration/matchers/be_called_with_no_arguments_spec.rb

@@ -1,34 +1,33 @@
 require 'spec_helper'
+include Rspec::Bash
 
 describe 'RSpec::Matchers' do
-  include Rspec::Bash
   let(:stubbed_env) { create_stubbed_env }
+  let!(:command) { stubbed_env.stub_command('stubbed_command') }
 
   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(
+        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
+        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(
+        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
+        expect(command).to_not be_called_with_no_arguments
       end
     end
   end

data/spec/integration/stubbed_command/outputs_spec.rb

@@ -1,87 +1,98 @@
 require 'spec_helper'
+include Rspec::Bash
+
+def execute_script(script)
+  let!(:execute_results) do
+    stdout, stderr, status = stubbed_env.execute_inline(
+      script
+    )
+    [stdout, stderr, status]
+  end
+  let(:stdout) { execute_results[0] }
+  let(:stderr) { execute_results[1] }
+  let(:exitcode) { execute_results[2].exitstatus }
+end
 
 describe 'StubbedCommand' do
-  include Rspec::Bash
   let(:stubbed_env) { create_stubbed_env }
-  let!(:command1_stub) { stubbed_env.stub_command('command1') }
+  let!(:command) { stubbed_env.stub_command('stubbed_command') }
 
   describe '#outputs' do
     describe 'target stdout' do
       context 'when given no arguments to match' do
-        let(:output) do
-          command1_stub
-            .outputs('hello', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 first_argument second_argument')
-          output
+        before do
+          command.outputs("\nhello\n", to: :stdout)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'hello'
+          expect(stdout).to eql "\nhello\n"
         end
       end
       context 'when given an exact argument match' do
-        let(:output) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', 'second_argument')
-            .outputs('hello', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 first_argument second_argument')
-          output
+            .outputs("\nhello\n", to: :stdout)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'hello'
+          expect(stdout).to eql "\nhello\n"
         end
       end
       context 'when given an anything argument match' do
-        let(:output) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', anything)
             .outputs('i respond to anything', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 first_argument piglet')
-          output
         end
 
+        execute_script('stubbed_command first_argument piglet')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'i respond to anything'
+          expect(stdout).to eql 'i respond to anything'
         end
       end
       context 'when given any_args argument match' do
-        let(:output) do
-          command1_stub
+        before do
+          command
             .with_args(any_args)
             .outputs('i respond to any_args', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 poglet piglet')
-          output
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'i respond to any_args'
+          expect(stdout).to eql 'i respond to any_args'
         end
       end
       context 'when given other types of RSpec::Mock::ArgumentMatcher argument match' do
-        let(:output) do
-          command1_stub
+        before do
+          command
             .with_args(instance_of(String), instance_of(String))
             .outputs('i respond to instance_of', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 poglet 1')
-          output
         end
 
+        execute_script('stubbed_command poglet 1')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'i respond to instance_of'
+          expect(stdout).to eql 'i respond to instance_of'
         end
       end
       context 'when given regex argument match' do
-        let(:output) do
-          command1_stub
+        before do
+          command
             .with_args(/p.glet/, /p.glet/)
             .outputs('i respond to regex', to: :stdout)
-          output, = stubbed_env.execute_inline('command1 poglet piglet')
-          output
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected output to stdout' do
-          expect(output).to eql 'i respond to regex'
+          expect(stdout).to eql 'i respond to regex'
         end
       end
     end
@@ -89,153 +100,160 @@ describe 'StubbedCommand' do
     # TODO: it is a bug that these require a \n in the output
     describe 'target stderr' do
       context 'when given no arguments to match' do
-        let(:error) do
-          command1_stub
-            .outputs('hello', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 first_argument second_argument')
-          error
+        before do
+          command
+            .outputs("\nhello\n", to: :stderr)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "hello\n"
+          expect(stderr).to eql "\nhello\n"
         end
       end
       context 'when given an exact argument match' do
-        let(:error) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', 'second_argument')
-            .outputs('hello', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 first_argument second_argument')
-          error
+            .outputs("\nhello\n", to: :stderr)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "hello\n"
+          expect(stderr).to eql "\nhello\n"
         end
       end
       context 'when given an anything argument match' do
-        let(:error) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', anything)
             .outputs('i respond to anything', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 first_argument piglet')
-          error
         end
 
+        execute_script('stubbed_command first_argument piglet')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "i respond to anything\n"
+          expect(stderr).to eql "i respond to anything\n"
         end
       end
       context 'when given any_args argument match' do
-        let(:error) do
-          command1_stub
+        before do
+          command
             .with_args(any_args)
             .outputs('i respond to any_args', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 poglet piglet')
-          error
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "i respond to any_args\n"
+          expect(stderr).to eql "i respond to any_args\n"
         end
       end
       context 'when given other types of RSpec::Mock::ArgumentMatcher argument match' do
-        let(:error) do
-          command1_stub
+        before do
+          command
             .with_args(instance_of(String), instance_of(String))
             .outputs('i respond to instance_of', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 poglet 1')
-          error
         end
 
+        execute_script('stubbed_command poglet 1')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "i respond to instance_of\n"
+          expect(stderr).to eql "i respond to instance_of\n"
         end
       end
       context 'when given regex argument match' do
-        let(:error) do
-          command1_stub
+        before do
+          command
             .with_args(/p.glet/, /p.glet/)
             .outputs('i respond to regex', to: :stderr)
-          _, error, = stubbed_env.execute_inline('command1 poglet piglet')
-          error
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected error to stderr' do
-          expect(error).to eql "i respond to regex\n"
+          expect(stderr).to eql "i respond to regex\n"
         end
       end
     end
 
     describe 'target file path' do
       let(:temp_file) { Tempfile.new('for-testing') }
+
       context 'when given no arguments to match' do
-        before(:each) do
-          command1_stub
-            .outputs('hello', to: temp_file.path)
-          stubbed_env.execute_inline('command1 first_argument second_argument')
+        before do
+          command
+            .outputs("\nhello\n", to: temp_file.path)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected content to the file' do
-          expect(temp_file.read).to eql 'hello'
+          expect(temp_file.read).to eql "\nhello\n"
         end
       end
       context 'when given an exact argument match' do
-        before(:each) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', 'second_argument')
-            .outputs('hello', to: temp_file.path)
-          stubbed_env.execute_inline('command1 first_argument second_argument')
+            .outputs("\nhello\n", to: temp_file.path)
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected content to the file' do
-          expect(temp_file.read).to eql 'hello'
+          expect(temp_file.read).to eql "\nhello\n"
         end
       end
       context 'when given an anything argument match' do
-        before(:each) do
-          command1_stub
+        before do
+          command
             .with_args('first_argument', anything)
             .outputs('i respond to anything', to: temp_file.path)
-          stubbed_env.execute_inline('command1 first_argument second_argument')
         end
 
+        execute_script('stubbed_command first_argument second_argument')
+
         it 'outputs the expected content to the file' do
           expect(temp_file.read).to eql 'i respond to anything'
         end
       end
       context 'when given any_args argument match' do
-        before(:each) do
-          command1_stub
+        before do
+          command
             .with_args(any_args)
             .outputs('i respond to any_args', to: temp_file.path)
-          stubbed_env.execute_inline('command1 poglet piglet')
         end
 
+        execute_script('stubbed_command first_argument poglet')
+
         it 'outputs the expected content to the file' do
           expect(temp_file.read).to eql 'i respond to any_args'
         end
       end
       context 'when given other types of RSpec::Mock::ArgumentMatcher argument match' do
-        before(:each) do
-          command1_stub
+        before do
+          command
             .with_args(instance_of(String), instance_of(String))
             .outputs('i respond to instance_of', to: temp_file.path)
-          stubbed_env.execute_inline('command1 poglet 1')
         end
 
+        execute_script('stubbed_command poglet 1')
+
         it 'outputs the expected content to the file' do
           expect(temp_file.read).to eql 'i respond to instance_of'
         end
       end
       context 'when given regex argument match' do
-        before(:each) do
-          command1_stub
+        before do
+          command
             .with_args(/p.glet/, /p.glet/)
             .outputs('i respond to regex', to: temp_file.path)
-          stubbed_env.execute_inline('command1 poglet piglet')
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected content to the file' do
           expect(temp_file.read).to eql 'i respond to regex'
         end
@@ -243,12 +261,14 @@ describe 'StubbedCommand' do
 
       describe 'when given a passed argument for a filename' do
         let(:dynamic_file) { Pathname.new('output-piglet.txt') }
-        before(:each) do
-          command1_stub
+
+        before do
+          command
             .outputs('i have a dynamic file name', to: ['output-', :arg2, '.txt'])
-          stubbed_env.execute_inline('command1 poglet piglet')
         end
 
+        execute_script('stubbed_command poglet piglet')
+
         it 'outputs the expected content to the file' do
           expect(dynamic_file.read).to eql 'i have a dynamic file name'
         end