shoulda-matchers 2.7.0 → 2.8.0.rc1

data/spec/support/tests/command_runner.rb

@@ -0,0 +1,214 @@
+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, :directory
+    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 = ''
+      @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=(directory)
+      @directory = 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
+          debug { "\n\e[32mRunning command:\e[0m #{formatted_command}" }
+          wrapper.call(-> { run })
+          debug { "\n" + divider('START') + output + divider('END') }
+
+          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 #{command.inspect} exited with status #{exit_status}.
+Output:
+#{divider('START') + output + divider('END')}
+      MESSAGE
+    end
+
+    def has_output?(expected_output)
+      output.include?(expected_output)
+    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
+      Dir.chdir(directory) do
+        pid = spawn(env, *command, options)
+        Process.waitpid(pid)
+      end
+
+      @status = $?
+    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" +
+            elided_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/filesystem.rb

@@ -0,0 +1,77 @@
+require 'fileutils'
+
+module Tests
+  class Filesystem
+    PROJECT_NAME = 'test-project'
+    ROOT_DIRECTORY = Pathname.new('../../../..').expand_path(__FILE__)
+    TEMP_DIRECTORY = ROOT_DIRECTORY.join('tmp/acceptance')
+    PROJECT_DIRECTORY = TEMP_DIRECTORY.join(PROJECT_NAME)
+
+    def root_directory
+      ROOT_DIRECTORY
+    end
+
+    def temp_directory
+      TEMP_DIRECTORY
+    end
+
+    def project_directory
+      PROJECT_DIRECTORY
+    end
+
+    def wrap(path)
+      if path.is_a?(Pathname)
+        path
+      else
+        find_in_project(path)
+      end
+    end
+
+    def within_project(&block)
+      Dir.chdir(project_directory, &block)
+    end
+
+    def clean
+      if temp_directory.exist?
+        temp_directory.rmtree
+      end
+    end
+
+    def create
+      project_directory.mkpath
+    end
+
+    def find_in_project(path)
+      project_directory.join(path)
+    end
+
+    def open(path, *args, &block)
+      find_in_project(path).open(*args, &block)
+    end
+
+    def read(path)
+      find_in_project(path).read
+    end
+
+    def write(path, content)
+      pathname = wrap(path)
+      create_parents_of(pathname)
+      pathname.open('w') { |f| f.write(content) }
+    end
+
+    def create_parents_of(path)
+      wrap(path).dirname.mkpath
+    end
+
+    def append_to_file(path, content, options = {})
+      create_parents_of(path)
+      open(path, 'a') { |f| f.puts(content + "\n") }
+    end
+
+    def remove_from_file(path, pattern)
+      content = read(path)
+      content.sub!(/#{pattern}\n/, '')
+      write(path, content)
+    end
+  end
+end

data/spec/support/tests/version.rb

@@ -0,0 +1,45 @@
+module Tests
+  class Version
+    def initialize(version)
+      @version = Gem::Version.new(version.to_s + '')
+    end
+
+    def <(other_version)
+      compare?(:<, other_version)
+    end
+
+    def <=(other_version)
+      compare?(:<=, other_version)
+    end
+
+    def ==(other_version)
+      compare?(:==, other_version)
+    end
+
+    def >=(other_version)
+      compare?(:>=, other_version)
+    end
+
+    def >(other_version)
+      compare?(:>, other_version)
+    end
+
+    def =~(other_version)
+      Gem::Requirement.new(other_version).satisfied_by?(version)
+    end
+
+    def to_s
+      version.to_s
+    end
+
+    protected
+
+    attr_reader :version
+
+    private
+
+    def compare?(op, other_version)
+      Gem::Requirement.new("#{op} #{other_version}").satisfied_by?(version)
+    end
+  end
+end

data/spec/support/unit/capture.rb

@@ -0,0 +1,34 @@
+module Kernel
+  # #capture, #silence_stream, and #silence_stderr are deprecated after Rails
+  # 4.2 and will be removed in 5.0, so just override them completely here
+
+  def capture(stream)
+    stream = stream.to_s
+    captured_stream = Tempfile.new(stream)
+    stream_io = eval("$#{stream}")
+    origin_stream = stream_io.dup
+    stream_io.reopen(captured_stream)
+
+    yield
+
+    stream_io.rewind
+    return captured_stream.read
+  ensure
+    captured_stream.unlink
+    stream_io.reopen(origin_stream)
+  end
+
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+    old_stream.close
+  end
+
+  def silence_stderr
+    silence_stream(STDERR) { yield }
+  end
+end

data/spec/support/unit/helpers/active_model_helpers.rb

@@ -0,0 +1,25 @@
+module UnitTests
+  module ActiveModelHelpers
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+    end
+
+    def custom_validation(options = {}, &block)
+      attribute_name = options.fetch(:attribute_name, :attr)
+      attribute_type = options.fetch(:attribute_type, :integer)
+
+      define_model(:example, attribute_name => attribute_type) do
+        validate :custom_validation
+
+        define_method(:custom_validation, &block)
+      end.new
+    end
+    alias record_with_custom_validation custom_validation
+
+    def validating_format(options)
+      define_model :example, attr: :string do
+        validates_format_of :attr, options
+      end.new
+    end
+  end
+end

data/spec/support/unit/helpers/active_model_versions.rb

@@ -0,0 +1,20 @@
+module UnitTests
+  module ActiveModelVersions
+    def self.configure_example_group(example_group)
+      example_group.include(self)
+      example_group.extend(self)
+    end
+
+    def active_model_3_1?
+      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1) || active_model_4_0?
+    end
+
+    def active_model_3_2?
+      (::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 2) || active_model_4_0?
+    end
+
+    def active_model_4_0?
+      ::ActiveModel::VERSION::MAJOR == 4
+    end
+  end
+end

data/spec/support/unit/helpers/active_resource_builder.rb

@@ -0,0 +1,27 @@
+require 'active_resource'
+
+module UnitTests
+  module ActiveResourceBuilder
+    def self.configure_example_group(example_group)
+      example_group.include ActiveResourceBuilder
+
+      example_group.after do
+        ActiveSupport::Dependencies.clear
+      end
+    end
+
+    def define_active_resource_class(class_name, attributes = {}, &block)
+      define_class(class_name, ActiveResource::Base) do
+        schema do
+          attributes.each do |attr, type|
+            attribute attr, type
+          end
+        end
+
+        if block_given?
+          class_eval(&block)
+        end
+      end
+    end
+  end
+end