rspec-bash 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea2520732451e6815750cf97022a407cfb0f19ef
-  data.tar.gz: 5d11657c4897d0ffcaff2e137b8da47c8bc8ac17
+  metadata.gz: 5264f0b8921b472fdb32e393e55004b5e1f3c885
+  data.tar.gz: bf99d54315422b4e885dfabab09729e39e94053c
 SHA512:
-  metadata.gz: 922d168641fd597e4c98555f365ea51f4ee426ac685a0a86b8980287752b00163e59975015f4e1b134908b6f95e270a0d811b61902740a12ac52da5e46251ccf
-  data.tar.gz: 97cade40565fd8fec2662a192308db8e56f07d4b70824338cdbc7621671d03e61c2354e52b890f90f7e805ccddd47d31c4c34f7f00514840f470e06d8a4a8d99
+  metadata.gz: 3bffee5f454d467b72a797016d1745cc1c5c6aa1743a4b24654394bd762738d953678d42350806e67a0a5c78c976fe99a05c2bc39793715b90a1cafffa811703
+  data.tar.gz: b9cb113c2ead82843566c750ce0b4fcf7f98e97a63117df42e8a2c603dbacac27243a0bcf2aaabff60b775c39f681f1bdc65910ef3fde1833c1590cd32c116d5

data/.rubocop.yml

@@ -0,0 +1,30 @@
+Metrics/LineLength:
+  Max: 100
+
+Style/NumericLiteralPrefix:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Lint/HandleExceptions:
+  Exclude:
+    - 'spec/classes/stub_spec.rb'
+
+Metrics/BlockLength:
+  Max: 428
+
+Security/YAMLLoad:
+  Exclude:
+    - 'bin/stub.rb.erb'
+    - 'spec/classes/stub_spec.rb'
+    - 'lib/rspec/bash/call_configuration.rb'
+    - 'lib/rspec/bash/call_log.rb'
+    - 'spec/classes/util/call_conf_argument_list_matcher_spec.rb'
+
+Metrics/BlockLength:
+  Max: 1000
+
+Style/TrivialAccessors:
+  Exclude:
+    - 'lib/rspec/bash/call_log.rb'

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 sudo: false
 rvm:
+  - 2.2.0
   - 2.1.0
   - 2.0.0
   - ruby-head

data/Gemfile

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
-gemspec
-gem 'rubocop'
+gem 'rainbow', '>= 2.1.0', '< 2.2.0'
 gem 'rake'
-gem 'rspec'
-gem 'simplecov'
+gem 'rspec', '3.5.0'
+gem 'rubocop', '0.47.1'
+gem 'simplecov', require: false, group: :test

data/README.md

@@ -1,3 +1,6 @@
+[![Stories in Ready](https://badge.waffle.io/mdurban/rspec-bash.png?label=ready&title=Ready)](http://waffle.io/mdurban/rspec-bash)
+[![Build Status](https://travis-ci.org/mdurban/rspec-bash.svg?branch=master)](https://travis-ci.org/mdurban/rspec-bash)
+
 # Rspec::Bash
 
 Run your shell script in a mocked environment to test its behavior using RSpec.
@@ -6,13 +9,11 @@ Run your shell script in a mocked environment to test its behavior using RSpec.
 - Test bash functions, entire scripts and inline scripts
 - Stub shell commands and their exitstatus and outputs
 - Partial mocks of functions
-- Control exit status codes
 - Control multiple outputs (through STDOUT, STDERR or files)
 - Verify STDIN, STDOUT, STDERR
-- Verify if command is called
-- Verify command is called with specific argument sequence
+- Verify command was called with specific argument sequence
 - Verify command was called correct number of times
-- Supports RSpec "anything" wildcard matchers
+- Supports RSpec matchers
 
 ## Installation
 
@@ -60,7 +61,7 @@ see specs in *spec/integration* folder:
     it 'runs the script' do
       stdout, stderr, status = stubbed_env.execute(
         'my-shell-script.sh',
-        { 'SOME_OPTIONAL' => 'env vars' }
+        { 'OPTIONAL_ENV' => 'env vars' }
       )
       expect(status.exitstatus).to eq 0
     end
@@ -82,134 +83,143 @@ see specs in *spec/integration* folder:
 ### Changing exitstatus of stubs:
 
 ```ruby
-  let(:stubbed_env) { create_stubbed_env }
-  before do
-    stubbed_env.stub_command('rake').returns_exitstatus(5)
-    stubbed_env.stub_command('rake').with_args('spec').returns_exitstatus(3)
-  end
+  stubbed_env.stub_command('rake').returns_exitstatus(5)
+```
+
+```ruby
+  stubbed_env.stub_command('rake').with_args('spec').returns_exitstatus(3)
 ```
 
 ### Stubbing output:
 
 ```ruby
-  let(:stubbed_env) { create_stubbed_env }
-  let(:rake_stub) { stubbed_env.stub_command 'rake' }
-  before do
-    rake_stub.outputs('informative message', to: :stdout)
-      .outputs('error message', to: :stderr)
-      .outputs('log contents', to: 'logfile.log')
-      .outputs('converted result', to: ['prefix-', :arg2, '.txt'])
-    # last one creates 'prefix-foo.txt' when called as 'rake convert foo'
-  end
+  let(:rake_stub) { stubbed_env.stub_command('rake') }
+
+  rake_stub.outputs('informative message', to: :stdout)
+    .outputs('error message', to: :stderr)
+    .outputs('log contents', to: 'logfile.log')
+    # creates 'prefix-foo.txt' when called as 'rake convert foo'
+    .outputs('converted result', to: ['prefix-', :arg2, '.txt'])
 ```
 
 ### Verifying stdin:
 
 ```ruby
   let(:stubbed_env) { create_stubbed_env }
-  let(:cat_stub) { stubbed_env.stub_command 'cat' }
-  let(:mail_stub) { stubbed_env.stub_command 'mail' }
-  it 'verifies stdin' do
-    stubbed_env.execute_script 'script.sh'
+
+  it 'verifies stdin with no args' do
+    cat_stub = stubbed_env.stub_command('cat')
+
     expect(cat_stub.stdin).to eql 'hello'
+  end
+
+  it 'verifies stdin with args' do
+    mail_stub = stubbed_env.stub_command('mail')
+
     expect(mail_stub.with_args('-s', 'hello').stdin).to eql 'world'
   end
 ```
-### Test entire script
+
+### Test entire script, specific function or inline script
 
 ```ruby
-let(:stubbed_env) { Rspec::Bash::StubbedEnv.new }
 stubbed_env.execute('./path/to/script.sh')
 ```
 
-### Test specific function
-
 ```ruby
-let(:stubbed_env) { Rspec::Bash::StubbedEnv.new }
-stubbed_env.stub_command('overridden_function')
 stubbed_env.execute_function(
     './path/to/script.sh',
     'overridden_function'
 )
-
 ```
 
-### Test inline script
-
 ```ruby
-let(:stubbed_env) { create_stubbed_env }
-stubbed_env.stub_command('stubbed_command')
 stubbed_env.execute_inline(<<-multiline_script
     stubbed_command first_argument second_argument
     multiline_script
 )
-
 ```
+
 ### Check that mock was called with specific arguments
 
 ```ruby
-describe 'be_called_with_arguments' do
-  include Rspec::Bash
-  let(:stubbed_env) { create_stubbed_env }
+stubbed_env.execute_inline(<<-multiline_script
+  stubbed_command first_argument second_argument
+ multiline_script
+)
 
-  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
-    end
-  end
+it 'correctly identifies the called arguments' do
+  expect(@command).to be_called_with_arguments('first_argument', 'second_argument')
 end
 ```
 
 ### Check that mock was not called with any arguments
 
 ```ruby
-@command = stubbed_env.stub_command('stubbed_command')
-stubbed_env.execute_inline(<<-multiline_script
-  stubbed_command
-multiline_script
+expect(@command).to be_called_with_no_arguments
+```
 
-it 'correctly identifies that no arguments were called' do
-  expect(@command).to be_called_with_no_arguments
+### Check that mock was called a certain number of times
+```ruby
+  @actual_stdout, @actual_stderr, @actual_status = stubbed_env.execute_inline(<<-multiline_script
+    stubbed_command duplicated_argument
+    stubbed_command duplicated_argument
+    stubbed_command once_called_argument
+  multiline_script
+
+  expect(@command).to be_called_with_arguments('duplicated_argument').times(2)
+  expect(@command).to be_called_with_arguments('once_called_argument').times(1)
 end
 ```
 
-### Check that mock was called a certain number of times
+### Supports RSpec matchers
 ```ruby
-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
-      stubbed_command duplicated_argument
-      stubbed_command once_called_argument
-    multiline_script
-    )
-  end
-  it 'matches when arguments are called twice' do
-    expect(@command).to be_called_with_arguments('duplicated_argument').times(2)
-  end
-  it 'matches when argument is called once' do
-    expect(@command).to be_called_with_arguments('once_called_argument').times(1)
-  end
+it 'stub call with a wildcard used for an argument' do
+  grep_mock = stubbed_env.stub_command('grep')
+  grep_mock.with_args('-r', anything).outputs('output from grep')
+
+  expect(command).to be_called_with_arguments('output from grep')
 end
 ```
 
-### Use rspec "anything" wildcards for arguments you don't need to match exactly
 ```ruby
 it 'correctly matches when wildcard is used for arguments' do
   expect(@command).to be_called_with_arguments(anything, 'second_argument', anything)
 end
 ```
 
+```ruby
+it 'matches any arguments' do
+  expect(@command).to be_called_with_arguments
+end
+```
+
+```ruby
+it 'matches all arguments' do
+  expect(@command).to be_called_with_arguments(any_args)
+end
+```
+
+```ruby
+it 'matches any String argument' do
+  expect(@command).to be_called_with_arguments(instance_of(String))
+end
+```
+
+```ruby
+it 'matches using regexp' do
+  expect(@command).to be_called_with_arguments(/s..arg/)
+end
+```
+
+### Pitfalls and known issues
+
+- Use `$BASH_SOURCE[0]` instead of `$0` in your Bash scripts when trying to get the directory that your called script is in. This is a good habit to use when writing scripts as `$0` should rarely be used.
+`$0` also has some ramifications when using this gem; it will always be `bash` and will not be the name of the script.
+Please see https://www.gnu.org/software/bash/manual/bashref.html#Positional-Parameters for more information on `$0`
+
+- The `execute_function()` method is recommended to be used only when testing Bash libraries. This is because it needs to source the entire file to run the function under test, so any executable code in the script will be run even if it is outside of the function being tested
+
 ## More examples
 
 see the *spec/integration* folder
@@ -220,7 +230,7 @@ Ruby 2+, no JRuby, due to issues with `Open3.capture3`
 
 ## Contributing
 
-1. Fork it ( https://github.com/mdurban/rspec-bash )
+1. Fork it (https://github.com/mdurban/rspec-bash)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -1,6 +1,6 @@
 require 'bundler/gem_tasks'
-
 require 'rspec/core/rake_task'
+
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
   t.rspec_opts = '--format documentation'

data/bin/function_override_wrapper.sh.erb

@@ -1,6 +1,9 @@
 /usr/bin/env bash -c '
 # load in command and function overrides
-for override_file in <%=function_override_path_binding_for_template%>; do
+system_ls=$(which ls)
+system_grep=$(which grep)
+
+for override_file in $(${system_ls} -d <%=function_override_path_binding_for_template%> 2> /dev/null); do
   source ${override_file}
 done
 
@@ -10,7 +13,7 @@ done
 command_exit_code=$?
 
 # filter stderr for readonly problems
-grep -v "readonly function" <%=wrapped_error_path_binding_for_template%> >&2
+${system_grep} -v "readonly function" <%=wrapped_error_path_binding_for_template%> >&2
 
 # return original exit code
-exit ${command_exit_code}'
+exit ${command_exit_code}'

data/bin/stub.rb.erb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift('<%= rspec_bash_library_path_for_template %>')
+
+require 'rspec/bash'
+require 'pathname'
+require 'yaml'
+
+include Rspec::Bash
+
+command = File.basename(__FILE__)
+folder = File.dirname(__FILE__)
+
+call_log_path = Pathname.new(folder).join("#{command}_calls.yml")
+call_log = CallLog.new(call_log_path)
+call_log.add_log(STDIN.tty? ? '' : $stdin.read, ARGV)
+
+def interpolate_filename(elements)
+  return elements if elements.is_a? String
+  return nil unless elements.is_a? Array
+
+  elements.map do |element|
+    case element
+    when String then
+      element
+    when Symbol then
+      interpolate_argument(element)
+    end
+  end.join
+end
+
+def interpolate_argument(name)
+  return unless (data = /^arg(\d+)$/.match(name.to_s))
+  ARGV[data[1].to_i - 1]
+end
+
+call_conf_path = Pathname.new(folder).join("#{command}_stub.yml")
+if call_conf_path.exist?
+  call_conf = CallConfiguration.new(call_conf_path, command)
+  config = call_conf.call_configuration
+
+  call_conf_arg_matcher = Util::CallConfArgumentListMatcher.new(config)
+  best_matching_call_conf = call_conf_arg_matcher.get_best_call_conf(*ARGV)
+  exit 0 if best_matching_call_conf.empty?
+
+  (best_matching_call_conf[:outputs] || []).each do |data|
+    $stdout.print data[:content] if data[:target] == :stdout
+    $stderr.print data[:content] if data[:target] == :stderr
+
+    output_filename = interpolate_filename(data[:target])
+    next unless output_filename
+    Pathname.new(output_filename).open('w') do |f|
+      f.print data[:content]
+    end
+  end
+  exit best_matching_call_conf[:exitcode] || 0
+end

data/lib/rspec/bash.rb

@@ -1,4 +1,5 @@
 require 'rspec/bash/stubbed_command'
+require 'rspec/bash/util'
 require 'rspec/bash/call_configuration'
 require 'rspec/bash/call_log'
 require 'rspec/bash/stubbed_env'

data/lib/rspec/bash/call_configuration.rb

@@ -2,36 +2,61 @@ require 'yaml'
 
 module Rspec
   module Bash
-    # Configuration of a stubbed command
     class CallConfiguration
       attr_reader :command
 
       def initialize(config_path, command)
         @config_path = config_path
-        @configuration = {}
+        @configuration = []
         @command = command
       end
 
-      def set_exitcode(statuscode, args = [])
-        @configuration[args] ||= {}
-        @configuration[args][:statuscode] = statuscode
+      def set_exitcode(exitcode, args = [])
+        current_conf = create_or_get_conf(args)
+        current_conf[:exitcode] = exitcode
+        write @configuration
       end
 
-      def set_output(content, target, args = [])
-        @configuration[args] ||= {}
-        @configuration[args][:outputs] ||= []
-        @configuration[args][:outputs] << { target: target, content: content }
+      def add_output(content, target, args = [])
+        current_conf = create_or_get_conf(args)
+        current_conf[:outputs] << {
+          target: target,
+          content: content
+        }
+        write @configuration
       end
 
-      def write
-        structure = @configuration.map do |args, results|
-          { args: args }.merge results
+      def call_configuration
+        @config_path.open('r') do |conf_file|
+          YAML.load(conf_file.read) || []
         end
+      rescue NoMethodError, Errno::ENOENT
+        return []
+      end
+
+      def call_configuration=(new_conf)
+        write new_conf
+      end
 
-        @config_path.open('w') do |f|
-          f.puts structure.to_yaml
+      private
+
+      def write(call_conf_to_write)
+        @config_path.open('w') do |conf_file|
+          conf_file.write call_conf_to_write.to_yaml
         end
       end
+
+      def create_or_get_conf(args)
+        @configuration = call_configuration
+        new_conf = {
+          args: args,
+          exitcode: 0,
+          outputs: []
+        }
+        current_conf = @configuration.select { |conf| conf[:args] == args }
+        @configuration << new_conf if current_conf.empty?
+        current_conf.first || new_conf
+      end
     end
   end
 end