rspec-bash 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea2520732451e6815750cf97022a407cfb0f19ef
+  data.tar.gz: 5d11657c4897d0ffcaff2e137b8da47c8bc8ac17
+SHA512:
+  metadata.gz: 922d168641fd597e4c98555f365ea51f4ee426ac685a0a86b8980287752b00163e59975015f4e1b134908b6f95e270a0d811b61902740a12ac52da5e46251ccf
+  data.tar.gz: 97cade40565fd8fec2662a192308db8e56f07d4b70824338cdbc7621671d03e61c2354e52b890f90f7e805ccddd47d31c4c34f7f00514840f470e06d8a4a8d99

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.swp
+*.gem
+mkmf.log
+.idea/

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

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

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# 1.3.0
+
+  * Improved assertion message
+
+# 1.2.0
+
+  * Support for output filenames based on input arguments
+    (`.outputs('something', to: [:arg2, '.png'])`
+  * Updates local `ENV['PATH']` to easy test execution from private code
+  * Add `stubbed_env.cleanup` to cleanup `ENV['PATH']` manually
+
+# 1.1.0
+
+  * Support chaining of arguments in multiple steps
+    (`.with_args(...).with_args(...)`
+
+# 1.0.0
+
+ * Initial release
+ * Support for
+   * `create_stubbed_env`
+   * Execute script with env-vars
+   * Stubbing commands, output and exitstatus
+   * Asserting calls, arguments and stdin

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'rubocop'
+gem 'rake'
+gem 'rspec'
+gem 'simplecov'

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014 Matthijs Groen
+Modified (c) 2016 Ben Brewer, Mike Urban
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,227 @@
+# Rspec::Bash
+
+Run your shell script in a mocked environment to test its behavior using RSpec.
+
+## Features
+- 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 correct number of times
+- Supports RSpec "anything" wildcard matchers
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rspec-bash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rspec-bash
+
+
+You can setup rspec-bash globally for your spec suite:
+
+in `spec_helper.rb`:
+
+```ruby
+  require 'rspec/bash'
+
+  RSpec.configure do |c|
+    c.include Rspec::Bash
+  end
+```
+
+## Usage
+
+see specs in *spec/integration* folder:
+
+### Running script through stubbed env:
+
+```ruby
+  require 'rspec/bash'
+
+  describe 'my shell script' do
+    include Rspec::Bash
+
+    let(:stubbed_env) { create_stubbed_env }
+
+    it 'runs the script' do
+      stdout, stderr, status = stubbed_env.execute(
+        'my-shell-script.sh',
+        { 'SOME_OPTIONAL' => 'env vars' }
+      )
+      expect(status.exitstatus).to eq 0
+    end
+  end
+```
+
+### Stubbing commands:
+
+```ruby
+  let(:stubbed_env) { create_stubbed_env }
+  let!(:bundle) { stubbed_env.stub_command('bundle') }
+
+  it 'is stubbed' do
+    stubbed_env.execute 'my-script.sh'
+    expect(bundle).to be_called_with_arguments('install)
+  end
+```
+
+### 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
+```
+
+### 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
+```
+
+### 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'
+    expect(cat_stub.stdin).to eql 'hello'
+    expect(mail_stub.with_args('-s', 'hello').stdin).to eql 'world'
+  end
+```
+### Test entire 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 }
+
+  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
+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
+
+it 'correctly identifies that no arguments were called' do
+  expect(@command).to be_called_with_no_arguments
+end
+```
+
+### Check that mock was called a certain number of times
+```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
+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
+```
+
+## More examples
+
+see the *spec/integration* folder
+
+## Supported ruby versions
+
+Ruby 2+, no JRuby, due to issues with `Open3.capture3`
+
+## Contributing
+
+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`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+  t.rspec_opts = '--format documentation'
+  t.rspec_opts << ' --color'
+end
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: [:rubocop, :spec]

data/bin/function_override.sh.erb

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+function <%=function_command_binding_for_template%> {
+  <%=function_command_path_binding_for_template%> "${@}"
+}
+
+readonly -f <%=function_command_binding_for_template%> &> /dev/null

data/bin/function_override_wrapper.sh.erb

@@ -0,0 +1,16 @@
+/usr/bin/env bash -c '
+# load in command and function overrides
+for override_file in <%=function_override_path_binding_for_template%>; do
+  source ${override_file}
+done
+
+(
+  <%=execution_binding_for_template%>
+) 2> <%=wrapped_error_path_binding_for_template%>
+command_exit_code=$?
+
+# filter stderr for readonly problems
+grep -v "readonly function" <%=wrapped_error_path_binding_for_template%> >&2
+
+# return original exit code
+exit ${command_exit_code}'

data/bin/stub

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+require 'pathname'
+require 'yaml'
+
+command = File.basename(__FILE__)
+folder = File.dirname(__FILE__)
+
+call_logs = Pathname.new(folder).join("#{command}_calls.yml")
+call_logs.open('a') do |f|
+  f.puts '- args:'
+  ARGV.each { |arg| f.puts "  - #{arg.inspect}" }
+  f.puts "  stdin: #{$stdin.read.inspect}" unless STDIN.tty?
+end
+
+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_configurations = Pathname.new(folder).join("#{command}_stub.yml")
+if call_configurations.exist?
+  config = YAML.load call_configurations.read
+
+  matching_calls = []
+  config.each do |call_config|
+    if !call_config[:args].empty?
+      next unless (call_config[:args].eql? ARGV)
+    end
+    matching_calls << {
+      config: call_config,
+      specific: call_config[:args].length
+    }
+  end
+  exit 0 if matching_calls.empty?
+
+  call_config = matching_calls.sort do |a, b|
+    b[:specific] <=> a[:specific]
+  end.first[:config]
+  (call_config[: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 call_config[:statuscode] || 0
+end

data/lib/rspec/bash.rb

@@ -0,0 +1,5 @@
+require 'rspec/bash/stubbed_command'
+require 'rspec/bash/call_configuration'
+require 'rspec/bash/call_log'
+require 'rspec/bash/stubbed_env'
+require 'rspec/bash/matchers'

data/lib/rspec/bash/call_configuration.rb

@@ -0,0 +1,37 @@
+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 = {}
+        @command = command
+      end
+
+      def set_exitcode(statuscode, args = [])
+        @configuration[args] ||= {}
+        @configuration[args][:statuscode] = statuscode
+      end
+
+      def set_output(content, target, args = [])
+        @configuration[args] ||= {}
+        @configuration[args][:outputs] ||= []
+        @configuration[args][:outputs] << { target: target, content: content }
+      end
+
+      def write
+        structure = @configuration.map do |args, results|
+          { args: args }.merge results
+        end
+
+        @config_path.open('w') do |f|
+          f.puts structure.to_yaml
+        end
+      end
+    end
+  end
+end