shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/acceptance/matchers/indicate_that_tests_were_run_matcher.rb

@@ -1,103 +0,0 @@
-require_relative '../helpers/array_helpers'
-require_relative '../helpers/pluralization_helpers'
-require_relative '../helpers/rails_version_helpers'
-
-module AcceptanceTests
-  module Matchers
-    def indicate_that_tests_were_run(series)
-      IndicateThatTestsWereRunMatcher.new(series)
-    end
-
-    class IndicateThatTestsWereRunMatcher
-      include ArrayHelpers
-      include PluralizationHelpers
-      include RailsVersionHelpers
-
-      def initialize(args)
-        @args = args
-        @series = args.values
-      end
-
-      def matches?(runner)
-        @runner = runner
-        !matching_expected_output.nil?
-      end
-
-      def failure_message
-        "Expected output to indicate that #{some_tests_were_run}.\n" +
-          "#{formatted_expected_output}\n" +
-          "#{formatted_actual_output}\n"
-      end
-
-      protected
-
-      attr_reader :args, :series, :runner
-
-      private
-
-      def expected_outputs
-        [
-          expected_output_for_rails_3,
-          expected_output_for_turn,
-          expected_output_for_rails_4
-        ]
-      end
-
-      def matching_expected_output
-        @_matching_expected_output ||=
-          expected_outputs.detect do |expected_output|
-            actual_output =~ expected_output
-          end
-      end
-
-      def expected_output_for_rails_3
-        full_report = series.map do |number|
-          "#{number} tests, #{number} assertions, 0 failures, 0 errors(, 0 skips)?"
-        end.join('.+')
-
-        Regexp.new(full_report, Regexp::MULTILINE)
-      end
-
-      def expected_output_for_turn
-        full_report = series.map do |number|
-          "pass: #{number},  fail: 0,  error: 0"
-      end.join('.+')
-
-        Regexp.new(full_report, Regexp::MULTILINE)
-      end
-
-      def expected_output_for_rails_4
-        total = series.inject(:+)
-        /#{total} (tests|runs), #{total} assertions, 0 failures, 0 errors(, 0 skips)?/
-      end
-
-      def formatted_expected_output
-        if matching_expected_output
-          "Expected output:\n#{matching_actual_output}"
-        else
-          "Expected output: (n/a)"
-        end
-      end
-
-      def actual_output
-        runner.output
-      end
-
-      def formatted_actual_output
-        if actual_output.empty?
-          "Actual output: (empty)"
-        else
-          "Actual output:\n#{actual_output}"
-        end
-      end
-
-      def some_tests_were_run
-        clauses = args.map do |type, number|
-          pluralize(number, "#{type} test was run", "#{type} tests were run")
-        end
-
-        to_sentence(clauses)
-      end
-    end
-  end
-end

data/spec/support/tests/bundle.rb

@@ -1,94 +0,0 @@
-require_relative 'filesystem'
-require_relative 'command_runner'
-require_relative 'version'
-
-module Tests
-  class Bundle
-    def initialize
-      @already_updating = false
-      @fs = Filesystem.new
-    end
-
-    def updating(&block)
-      if already_updating?
-        yield self
-        return
-      end
-
-      @already_updating = true
-
-      yield self
-
-      @already_updating = false
-
-      install_gems
-    end
-
-    def add_gem(gem, *args)
-      updating do
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        version = args.shift
-        line = assemble_gem_line(gem, version, options)
-        fs.append_to_file('Gemfile', line)
-      end
-    end
-
-    def remove_gem(gem)
-      updating do
-        fs.comment_lines_matching('Gemfile', /^[ ]*gem ("|')#{gem}\1/)
-      end
-    end
-
-    def install_gems
-      CommandRunner.run!('bundle install --local') do |runner|
-        runner.retries = 5
-      end
-    end
-
-    def version_of(gem)
-      Version.new(Bundler.definition.specs[gem][0].version)
-    end
-
-    def includes?(gem)
-      Bundler.definition.dependencies.any? do |dependency|
-        dependency.name == gem
-      end
-    end
-
-    protected
-
-    attr_reader :fs
-
-    private
-
-    def already_updating?
-      @already_updating
-    end
-
-    def assemble_gem_line(gem, version, options)
-      formatted_options = options.
-        map { |key, value| "#{key}: #{formatted_value(value)}" }.
-        join(', ')
-
-      line = %(gem '#{gem}')
-
-      if version
-        line << %(, '#{version}')
-      end
-
-      if options.any?
-        line << %(, #{formatted_options})
-      end
-
-      line << "\n"
-    end
-
-    def formatted_value(value)
-      if value.is_a?(Pathname)
-        value.to_s.inspect
-      else
-        value.inspect
-      end
-    end
-  end
-end

data/spec/support/tests/command_runner.rb

@@ -1,230 +0,0 @@
-require 'timeout'
-require 'shellwords'
-
-module Tests
-  class CommandRunner
-    TimeoutError = Class.new(StandardError)
-
-    def self.run(*args)
-      new(*args).tap do |runner|
-        yield runner
-        runner.call
-      end
-    end
-
-    def self.run!(*args)
-      run(*args) do |runner|
-        runner.run_successfully = true
-        yield runner if block_given?
-      end
-    end
-
-    attr_reader :status, :options, :env
-    attr_accessor :command_prefix, :run_quickly, :run_successfully, :retries,
-      :timeout
-
-    def initialize(*args)
-      @reader, @writer = IO.pipe
-      options = (args.last.is_a?(Hash) ? args.pop : {})
-      @args = args
-      @options = options.merge(
-        err: [:child, :out],
-        out: writer
-      )
-      @env = extract_env_from(@options)
-
-      @wrapper = ->(block) { block.call }
-      @command_prefix = ''
-      self.directory = Dir.pwd
-      @run_quickly = false
-      @run_successfully = false
-      @retries = 1
-      @num_times_run = 0
-      @timeout = 20
-    end
-
-    def around_command(&block)
-      @wrapper = block
-    end
-
-    def directory
-      @options[:chdir]
-    end
-
-    def directory=(directory)
-      @options[:chdir] = directory || Dir.pwd
-    end
-
-    def formatted_command
-      [formatted_env, Shellwords.join(command)].
-        select { |value| !value.empty? }.
-        join(' ')
-    end
-
-    def call
-      possibly_retrying do
-        possibly_running_quickly do
-          run_with_debugging
-
-          if run_successfully && !success?
-            fail!
-          end
-        end
-      end
-
-      self
-    end
-
-    def stop
-      unless writer.closed?
-        writer.close
-      end
-    end
-
-    def output
-      @_output ||= begin
-        stop
-        without_colors(reader.read)
-      end
-    end
-
-    def elided_output
-      lines = output.split(/\n/)
-      new_lines = lines[0..4]
-
-      if lines.size > 10
-        new_lines << "(...#{lines.size - 10} more lines...)"
-      end
-
-      new_lines << lines[-5..-1]
-      new_lines.join("\n")
-    end
-
-    def success?
-      status.success?
-    end
-
-    def exit_status
-      status.exitstatus
-    end
-
-    def fail!
-      raise <<-MESSAGE
-Command #{formatted_command.inspect} exited with status #{exit_status}.
-Output:
-#{divider('START') + output + divider('END')}
-      MESSAGE
-    end
-
-    def has_output?(expected_output)
-      if expected_output.is_a?(Regexp)
-        output =~ expected_output
-      else
-        output.include?(expected_output)
-      end
-    end
-
-    protected
-
-    attr_reader :args, :reader, :writer, :wrapper
-
-    private
-
-    def extract_env_from(options)
-      options.delete(:env) { {} }.inject({}) do |hash, (key, value)|
-        hash[key.to_s] = value
-        hash
-      end
-    end
-
-    def command
-      ([command_prefix] + args).flatten.flat_map do |word|
-        Shellwords.split(word)
-      end
-    end
-
-    def formatted_env
-      env.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')
-    end
-
-    def run
-      pid = spawn(env, *command, options)
-      Process.waitpid(pid)
-      @status = $?
-    end
-
-    def run_with_wrapper
-      wrapper.call(method(:run))
-    end
-
-    def run_with_debugging
-      debug { "\n\e[33mChanging to directory:\e[0m #{directory}" }
-      debug { "\e[32mRunning command:\e[0m #{formatted_command}" }
-
-      run_with_wrapper
-
-      debug { "\n" + divider('START') + output + divider('END') }
-    end
-
-    def possibly_running_quickly(&block)
-      if run_quickly
-        begin
-          Timeout.timeout(timeout, &block)
-        rescue Timeout::Error
-          stop
-
-          message =
-            "Command timed out after #{timeout} seconds: #{formatted_command}\n" +
-            "Output:\n" +
-            output
-
-          raise TimeoutError, message
-        end
-      else
-        yield
-      end
-    end
-
-    def possibly_retrying
-      begin
-        @num_times_run += 1
-        yield
-      rescue => error
-        debug { "#{error.class}: #{error.message}" }
-
-        if @num_times_run < @retries
-          sleep @num_times_run
-          retry
-        else
-          raise error
-        end
-      end
-    end
-
-    def divider(title = '')
-      total_length = 72
-      start_length = 3
-
-      string = ''
-      string << ('-' * start_length)
-      string << title
-      string << '-' * (total_length - start_length - title.length)
-      string << "\n"
-      string
-    end
-
-    def without_colors(string)
-      string.gsub(/\e\[\d+(?:;\d+)?m(.+?)\e\[0m/, '\1')
-    end
-
-    def debugging_enabled?
-      ENV['DEBUG_COMMANDS'] == '1'
-    end
-
-    def debug(&block)
-      if debugging_enabled?
-        puts block.call
-      end
-    end
-  end
-end

data/spec/support/tests/current_bundle.rb

@@ -1,55 +0,0 @@
-require 'bundler'
-require 'appraisal'
-
-module Tests
-  class CurrentBundle
-    AppraisalNotSpecified = Class.new(ArgumentError)
-
-    include Singleton
-
-    def assert_appraisal!
-      unless appraisal_in_use?
-        message = <<EOT
-
-
-Please run tests starting with `appraisal <appraisal_name>`.
-Possible appraisals are: #{available_appraisals}
-
-EOT
-        raise AppraisalNotSpecified, message
-      end
-    end
-
-    def appraisal_in_use?
-      path.dirname == root.join('gemfiles')
-    end
-
-    def current_or_latest_appraisal
-      current_appraisal || latest_appraisal
-    end
-
-    def latest_appraisal
-      available_appraisals.sort.last
-    end
-
-    def available_appraisals
-      Appraisal::AppraisalFile.each.map(&:name)
-    end
-
-    private
-
-    def current_appraisal
-      if appraisal_in_use?
-        File.basename(path, ".gemfile")
-      end
-    end
-
-    def path
-      Bundler.default_gemfile
-    end
-
-    def root
-      Pathname.new('../../../..').expand_path(__FILE__)
-    end
-  end
-end