rspec-bash 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8768c8e7a3e2d1a30a82c8a7a4608786d38a619
-  data.tar.gz: aa8e860680f978205a989b10f7f141d89f4c9bb3
+  metadata.gz: 840b1879e77a1e03bd1d2b0ee87e1ccc47126294
+  data.tar.gz: 73cc3d08c7cb46f4f85198f477aeb2417d7774ed
 SHA512:
-  metadata.gz: 2ad5a2600f1aa8e2e30ff92834aedcbd070d01067f2f9e51683de3624c957ee6bbbd86214dd30bcd4d6816c86714156b2abafeee83791de33757acdaaccf2e4e
-  data.tar.gz: 4bd0fa4d49b57f6618c5ba970359d3f6a2472dc21b5d6d0c6c1f30d709f7f0e9e2eff1f50785cb10cfccece5458428c99d4da59340103377d57c9959e5d8adc8
+  metadata.gz: 853e2d1bcf90edcc2ce938269fd9360f225fc46f1a386f929955ad8544ea5de3b7e5bbd0da22b58a4bd0c402f8243901d49fad68e3d560569fd25c7051e00025
+  data.tar.gz: b1a371ab0fa15617d931ad5579d108189d7d0efe20087902dff1beb0ff3bdac136b21b43acba14dae73c7483e13088fbbb09d4926870e38546bb8b2b0633131a

data/.rubocop.yml

@@ -7,13 +7,21 @@ Style/NumericLiteralPrefix:
 Style/Documentation:
   Enabled: false
 
+Security/MarshalLoad:
+  Enabled: false
+
 Lint/HandleExceptions:
   Exclude:
     - 'spec/classes/stub_spec.rb'
+    - 'spec/classes/wrapper/ruby_stub_script_spec.rb'
 
 Metrics/BlockLength:
   Max: 428
 
+Metrics/MethodLength:
+  Exclude:
+    - 'lib/rspec/bash/stubbed_command.rb'
+
 Security/YAMLLoad:
   Exclude:
     - 'bin/stub.rb.erb'

data/Gemfile

@@ -5,3 +5,4 @@ gem 'rake'
 gem 'rspec', '3.5.0'
 gem 'rubocop', '0.47.1'
 gem 'simplecov', require: false, group: :test
+gem 'sparsify', '~> 1.1'

data/README.md

@@ -68,15 +68,37 @@ see specs in *spec/integration* folder:
   end
 ```
 
+### Choosing a stub type
+The stubbed functions/commands for the test runner were traditionally built with ruby. A faster alternative stub, written in bash, has recently been introduced, and is the current default. This can be configured, however, as shown.
+For ruby:
+```ruby
+let(:stubbed_env) { create_stubbed_env(StubbedEnv::RUBY_STUB) }
+```
+For bash (default, if not provided):
+```ruby
+let(:stubbed_env) { create_stubbed_env(StubbedEnv::BASH_STUB) }
+```
+
+Via environment variable:
+```bash
+export RSPEC_BASH_STUB_TYPE=ruby_stub
+# <run your tests here>
+...
+```
+
 ### Stubbing commands:
 
 ```ruby
   let(:stubbed_env) { create_stubbed_env }
   let!(:bundle) { stubbed_env.stub_command('bundle') }
+  let!(:absolute_command) { stubbed_env.stub_command('/path/to/bundle') }
+  let!(:relative_command) { stubbed_env.stub_command('./path/to/bundle') }
 
   it 'is stubbed' do
     stubbed_env.execute 'my-script.sh'
     expect(bundle).to be_called_with_arguments('install')
+    expect(absolute_command).to be_called_with_arguments('hello')
+    expect(relative_command).to be_called_with_arguments('world')
   end
 ```
 
@@ -220,6 +242,7 @@ Please see https://www.gnu.org/software/bash/manual/bashref.html#Positional-Para
 
 - 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
 
+- The current form of stub injection does not allow for stubs to be picked up by other commands. Ex. `xargs stubbed_command` will result in the `stubbed_command` not being found. There is a pending issue for this.
 ## More examples
 
 see the *spec/integration* folder

data/Rakefile

@@ -1,13 +1,24 @@
 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'
+def spec(task)
+  task.verbose = false
+  task.rspec_opts = '--format documentation'
+  task.rspec_opts << ' --color'
+end
+
+RSpec::Core::RakeTask.new(:spec_bash_stub) do |t|
+  ENV['RSPEC_BASH_STUB_TYPE'] = :bash_stub.to_s
+  spec(t)
+end
+
+RSpec::Core::RakeTask.new(:spec_ruby_stub) do |t|
+  ENV['RSPEC_BASH_STUB_TYPE'] = :ruby_stub.to_s
+  spec(t)
 end
 
 require 'rubocop/rake_task'
 RuboCop::RakeTask.new
 
+task spec: [:spec_bash_stub, :spec_ruby_stub]
 task default: [:rubocop, :spec]

data/bin/bash_stub.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+function json-encode {
+  echo -n ".${1}." |
+    awk '
+      BEGIN {RS=""}
+      {
+        gsub(/\\/, "\\\\")
+        gsub(/\"/, "\\\"")
+        gsub(/\t/, "\\t")
+        gsub(/\r/, "\\r")
+        gsub(/\b/, "\\b")
+        gsub(/\n/, "\\n")
+        print substr($0, 2, length($0)-2)
+      }
+    '
+}
+
+function json-decode {
+  echo -n "${1}" |
+    awk '
+      {
+        gsub(/\\"/, "\"")
+        print $0
+      }
+    '
+}
+
+function create-call-log {
+  command_name=${1}; shift
+  command_port=${1}; shift
+  raw_stdin=$([[ -t 0 ]] && echo -n '' || cat -; ret=$?; echo .; exit "$ret")
+
+  argument_list=( "${@}" )
+  command=$(
+    echo "\"command\":\"${command_name}\","
+  )
+  stdin=$(
+    echo "\"stdin\":\"$(json-encode "${raw_stdin%.}")\","
+  )
+  arguments=$(
+    for index in "${!argument_list[@]}"; do
+      arg="${argument_list[${index}]}"
+      echo "\"args.${index}\":\"$(json-encode "${arg}")\","
+    done
+  )
+
+  echo "{"
+  echo "${command}"
+  [[ -n "${arguments}" ]] && echo "${stdin}" || echo "${stdin%,}"
+  [[ -n "${arguments}" ]] && echo "${arguments%,}"
+  echo "}"
+}
+
+function send-to-server {
+  echo -n "${2}" | nc localhost ${1}
+}
+
+function extract-properties {
+  echo -n "${1}" | sed -En "s/^\"${2}\":\"?([^,\"]*)\"?,?$/\1/gp"
+}
+
+function print-output {
+  case ${1} in
+    stdout)
+      echo -en "${2}"
+      ;;
+    stderr)
+      echo -en "${2}" >&2
+      ;;
+    *)
+      echo -en "${2}" > ${1}
+      ;;
+  esac
+}
+function main {
+  client_message=$(create-call-log "${@}")
+  server_message=$(send-to-server "${2}" "${client_message}")
+  IFS=$'\n'
+  target_list=( $(extract-properties "${server_message}" "outputs\..*\.target") )
+  content_list=( $(extract-properties "${server_message}" "outputs\..*\.content") )
+  exit_code=$(extract-properties "${server_message}" "exitcode")
+
+  for index in "${!target_list[@]}"; do
+    target=${target_list[${index}]}
+    content=$(json-decode "${content_list[${index}]}")
+    print-output "${target}" "${content}"
+  done
+
+  exit ${exit_code}
+}
+
+[[ ${0} == ${BASH_SOURCE} ]] && main "${@}"

data/bin/bash_wrapper.sh.erb

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+<%=@override_list.join("\n")%>
+(
+<%=script%>
+) 2> <%=stderr_output_path%>
+command_exit_code=$?
+
+/usr/bin/env bash <<EOF
+  grep -v "readonly function" <%=stderr_output_path%> >&2
+EOF
+
+exit ${command_exit_code}

data/bin/ruby_stub.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'socket'
+
+name = ARGV.shift
+port = ARGV.shift
+
+sock = TCPSocket.new('localhost', port)
+call_from_client = {
+  command: name,
+  stdin:   STDIN.tty? ? '' : $stdin.read,
+  args:    ARGV
+}
+sock.write(Marshal.dump(call_from_client))
+sock.close_write
+conf_from_server = Marshal.load(sock.read)
+sock.close_read
+
+exit 0 if conf_from_server.empty?
+
+(conf_from_server[:outputs] || []).each do |data|
+  if data[:target] == :stdout
+    $stdout.print data[:content]
+    next
+  end
+  if data[:target] == :stderr
+    $stderr.print data[:content]
+    next
+  end
+  Pathname.new(data[:target]).open('w') do |f|
+    f.print data[:content]
+  end
+end
+exit conf_from_server[:exitcode] || 0

data/lib/rspec/bash.rb

@@ -1,6 +1,7 @@
-require 'rspec/bash/stubbed_command'
+require 'rspec/bash/command'
+require 'rspec/bash/matchers'
+require 'rspec/bash/server'
 require 'rspec/bash/util'
-require 'rspec/bash/call_configuration'
-require 'rspec/bash/call_log'
+require 'rspec/bash/wrapper'
+
 require 'rspec/bash/stubbed_env'
-require 'rspec/bash/matchers'

data/lib/rspec/bash/command.rb

@@ -0,0 +1,5 @@
+require 'rspec/bash/command/call_configuration'
+require 'rspec/bash/command/call_configuration_manager'
+require 'rspec/bash/command/call_log'
+require 'rspec/bash/command/call_log_manager'
+require 'rspec/bash/command/stubbed_command'

data/lib/rspec/bash/command/call_configuration.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+
+module Rspec
+  module Bash
+    class CallConfiguration
+      attr_accessor :call_configuration
+
+      def initialize
+        @call_configuration = []
+      end
+
+      def set_exitcode(exitcode, args = [])
+        current_conf = create_or_get_conf(args)
+        current_conf[:exitcode] = exitcode
+      end
+
+      def add_output(content, target, args = [])
+        current_conf = create_or_get_conf(args)
+        current_conf[:outputs] << {
+          target: target,
+          content: content
+        }
+      end
+
+      def get_best_call_conf(args = [])
+        call_conf_arg_matcher = Util::CallConfArgumentListMatcher.new(@call_configuration)
+        best_call_conf = call_conf_arg_matcher.get_best_call_conf(args)
+        remove_args_from_conf(
+          interpolate_output_targets(
+            best_call_conf,
+            args
+          )
+        )
+      end
+
+      private
+
+      def interpolate_output_targets(conf, args)
+        return conf if conf.empty?
+        conf[:outputs].each do |output|
+          output[:target] = interpolate_target(output[:target], args)
+        end
+        conf
+      end
+
+      def interpolate_target(target, args)
+        return target unless target.is_a? Array
+        target.map do |target_element|
+          next target_element if target_element.is_a? String
+          interpolate_argument(target_element, args)
+        end.join
+      end
+
+      def interpolate_argument(name, args)
+        matching_arg_index = /^arg(\d+)$/.match(name.to_s)
+        return name.to_s unless matching_arg_index
+        args[matching_arg_index[1].to_i - 1]
+      end
+
+      def remove_args_from_conf(conf)
+        conf.select { |key| ![:args].include?(key) }
+      end
+
+      def create_or_get_conf(args)
+        new_conf = {
+          args: args,
+          exitcode: 0,
+          outputs: []
+        }
+        current_conf = @call_configuration.select { |conf| conf[:args] == args }
+        @call_configuration << new_conf if current_conf.empty?
+        current_conf.first || new_conf
+      end
+    end
+  end
+end

data/lib/rspec/bash/command/call_configuration_manager.rb

@@ -0,0 +1,24 @@
+module Rspec
+  module Bash
+    class CallConfigurationManager
+      def initialize
+        @call_confs = Hash.new { |hash, key| hash[key] = CallConfiguration.new }
+      end
+
+      def set_exitcode(command, exitcode, args)
+        @call_confs[command]
+          .set_exitcode(exitcode, args)
+      end
+
+      def add_output(command, output, target, args)
+        @call_confs[command]
+          .add_output(output, target, args)
+      end
+
+      def get_best_call_conf(command, args)
+        @call_confs[command]
+          .get_best_call_conf(args)
+      end
+    end
+  end
+end

data/lib/rspec/bash/command/call_log.rb

@@ -0,0 +1,48 @@
+module Rspec
+  module Bash
+    class CallLog
+      attr_accessor :call_log
+
+      def initialize
+        @call_log = []
+      end
+
+      def stdin_for_args(argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(argument_list)
+        matching_call_log_list = call_argument_list_matcher.get_call_log_matches(call_log)
+        matching_call_log_list.first[:stdin] unless matching_call_log_list.empty?
+      end
+
+      def call_count(argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(argument_list)
+        call_argument_list_matcher.get_call_count(call_log)
+      end
+
+      def called_with_args?(argument_list)
+        call_argument_list_matcher = Util::CallLogArgumentListMatcher.new(argument_list)
+        call_argument_list_matcher.args_match?(call_log)
+      end
+
+      def called_with_no_args?
+        return false if @call_log.empty?
+
+        @call_log.all? do |call_log|
+          argument_list = call_log[:args] || []
+          argument_list.empty?
+        end
+      end
+
+      def add_log(stdin, argument_list)
+        updated_log = @call_log
+        updated_log << {
+          args: argument_list,
+          stdin: stdin
+        }
+      end
+
+      def call_log_arguments
+        @call_log.map { |call_log| call_log[:args] || [] }.compact
+      end
+    end
+  end
+end

data/lib/rspec/bash/command/call_log_manager.rb

@@ -0,0 +1,38 @@
+module Rspec
+  module Bash
+    class CallLogManager
+      def initialize
+        @call_logs = Hash.new { |hash, key| hash[key] = CallLog.new }
+      end
+
+      def add_log(command, stdin, arguments)
+        @call_logs[command]
+          .add_log(stdin, arguments)
+      end
+
+      def stdin_for_args(command, arguments)
+        @call_logs[command]
+          .stdin_for_args(arguments)
+      end
+
+      def call_count(command, arguments)
+        @call_logs[command]
+          .call_count(arguments)
+      end
+
+      def called_with_args?(command, arguments)
+        @call_logs[command]
+          .called_with_args?(arguments)
+      end
+
+      def called_with_no_args?(command)
+        @call_logs[command]
+          .called_with_no_args?
+      end
+
+      def call_log(command)
+        @call_logs[command]
+      end
+    end
+  end
+end