rspec-core 2.99.0 → 3.0.0

data/spec/spec_helper.rb

@@ -1,135 +0,0 @@
-require 'rubygems'
-
-begin
-  require 'spork'
-rescue LoadError
-  module Spork
-    def self.prefork
-      yield
-    end
-
-    def self.each_run
-      yield
-    end
-  end
-end
-
-Spork.prefork do
-  require 'rspec/autorun'
-  require 'autotest/rspec2'
-  require 'aruba/api'
-
-  if RUBY_PLATFORM == 'java'
-    # Works around https://jira.codehaus.org/browse/JRUBY-5678
-    require 'fileutils'
-    ENV['TMPDIR'] = File.expand_path('../../tmp', __FILE__)
-    FileUtils.mkdir_p(ENV['TMPDIR'])
-  end
-
-  Dir['./spec/support/**/*.rb'].map {|f| require f}
-
-  class NullObject
-    private
-    def method_missing(method, *args, &block)
-      # ignore
-    end
-  end
-
-  module Sandboxing
-    def self.sandboxed(&block)
-      @orig_config = RSpec.configuration
-      @orig_world  = RSpec.world
-      @orig_example = RSpec.current_example
-      new_config = RSpec::Core::Configuration.new
-      new_world  = RSpec::Core::World.new(new_config)
-      RSpec.configuration = new_config
-      RSpec.world = new_world
-      object = Object.new
-      object.extend(RSpec::Core::SharedExampleGroup)
-
-      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
-        alias_method :orig_run, :run
-        def run(reporter=nil)
-          RSpec.current_example = nil
-          orig_run(reporter || NullObject.new)
-        end
-      end
-
-      RSpec::Core::SandboxedMockSpace.sandboxed do
-        object.instance_eval(&block)
-      end
-    ensure
-      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
-        remove_method :run
-        alias_method :run, :orig_run
-        remove_method :orig_run
-      end
-
-      RSpec.configuration = @orig_config
-      RSpec.world = @orig_world
-      RSpec.current_example = @orig_example
-    end
-  end
-
-  def in_editor?
-    ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
-  end
-
-  module EnvHelpers
-    def with_env_vars(vars)
-      original = ENV.to_hash
-      vars.each { |k, v| ENV[k] = v }
-
-      begin
-        yield
-      ensure
-        ENV.replace(original)
-      end
-    end
-
-    def without_env_vars(*vars)
-      original = ENV.to_hash
-      vars.each { |k| ENV.delete(k) }
-
-      begin
-        yield
-      ensure
-        ENV.replace(original)
-      end
-    end
-  end
-
-  RSpec.configure do |c|
-    # structural
-    c.alias_it_behaves_like_to 'it_has_behavior'
-    c.around {|example| Sandboxing.sandboxed { example.run }}
-    c.include(RSpecHelpers)
-    c.include Aruba::Api, :example_group => {
-      :file_path => /spec\/command_line/
-    }
-
-    c.expect_with :rspec do |expectations|
-      expectations.syntax = :expect
-    end
-
-    # runtime options
-    c.treat_symbols_as_metadata_keys_with_true_values = true
-    c.color = !in_editor?
-    c.filter_run :focus
-    c.include EnvHelpers
-    c.run_all_when_everything_filtered = true
-    c.filter_run_excluding :ruby => lambda {|version|
-      case version.to_s
-      when "!jruby"
-        RUBY_ENGINE == "jruby"
-      when /^> (.*)/
-        !(RUBY_VERSION.to_s > $1)
-      else
-        !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
-      end
-    }
-  end
-end
-
-Spork.each_run do
-end

data/spec/support/config_options_helper.rb

@@ -1,15 +0,0 @@
-module ConfigOptionsHelper
-  extend RSpec::SharedContext
-
-  around(:each) { |e| without_env_vars('SPEC_OPTS', &e) }
-
-  def config_options_object(*args)
-    coo = RSpec::Core::ConfigurationOptions.new(args)
-    coo.parse_options
-    coo
-  end
-
-  def parse_options(*args)
-    config_options_object(*args).options
-  end
-end

data/spec/support/helper_methods.rb

@@ -1,55 +0,0 @@
-module RSpecHelpers
-  def relative_path(path)
-    RSpec::Core::Metadata.relative_path(path)
-  end
-
-  def ignoring_warnings
-    original = $VERBOSE
-    $VERBOSE = nil
-    result = yield
-    $VERBOSE = original
-    result
-  end
-
-  def safely
-    Thread.new do
-      ignoring_warnings { $SAFE = 3 }
-      yield
-    end.join
-
-    # $SAFE is not supported on Rubinius
-    unless defined?(Rubinius)
-      expect($SAFE).to eql 0 # $SAFE should not have changed in this thread.
-    end
-  end
-
-  def expect_deprecation_with_call_site(file, line, deprecated = //)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to include([file, line].join(':'))
-      expect(options[:deprecated]).to match(deprecated)
-    end
-  end
-
-  def expect_deprecation_with_no_call_site(deprecated)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options).to include(:call_site => nil)
-      expect(options[:deprecated]).to match(deprecated)
-    end
-  end
-
-  def expect_warn_deprecation_with_call_site(file, line, deprecated = //)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:message]).to include([file, line].join(':'))
-      expect(options[:message]).to match(deprecated)
-    end
-  end
-
-  def expect_no_deprecation
-    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
-  end
-
-  def allow_deprecation
-    allow(RSpec.configuration.reporter).to receive(:deprecation)
-  end
-
-end

data/spec/support/in_sub_process.rb

@@ -1,37 +0,0 @@
-module InSubProcess
-  if RUBY_PLATFORM == 'java'
-    def in_sub_process
-      pending "This spec requires forking to work properly, " +
-              "and JRuby does not support forking"
-    end
-  else
-    # Useful as a way to isolate a global change to a subprocess.
-    def in_sub_process
-      readme, writeme = IO.pipe
-
-      pid = Process.fork do
-        exception = nil
-        begin
-          yield
-        rescue Exception => e
-          exception = e
-        end
-
-        writeme.write Marshal.dump(exception)
-
-        readme.close
-        writeme.close
-        exit! # prevent at_exit hooks from running (e.g. minitest)
-      end
-
-      writeme.close
-      Process.waitpid(pid)
-
-      exception = Marshal.load(readme.read)
-      readme.close
-
-      raise exception if exception
-    end
-  end
-end
-

data/spec/support/isolate_load_path_mutation.rb

@@ -1,6 +0,0 @@
-shared_context "isolate load path mutation" do
-  original_load_path = nil
-  before { original_load_path = $LOAD_PATH.dup }
-  after  { $LOAD_PATH.replace(original_load_path) }
-end
-

data/spec/support/isolated_directory.rb

@@ -1,10 +0,0 @@
-require 'tmpdir'
-require 'fileutils'
-
-shared_context "isolated directory", :isolated_directory => true do
-  around do |ex|
-    Dir.mktmpdir do |tmp_dir|
-      Dir.chdir(tmp_dir, &ex)
-    end
-  end
-end

data/spec/support/isolated_home_directory.rb

@@ -1,16 +0,0 @@
-require 'tmpdir'
-require 'fileutils'
-
-shared_context "isolated home directory", :isolated_home => true do
-  around do |ex|
-    Dir.mktmpdir do |tmp_dir|
-      original_home = ENV['HOME']
-      begin
-        ENV['HOME'] = tmp_dir
-        ex.call
-      ensure
-        ENV['HOME'] = original_home
-      end
-    end
-  end
-end

data/spec/support/matchers.rb

@@ -1,65 +0,0 @@
-RSpec::Matchers.define :map_specs do |specs|
-  match do |autotest|
-    @specs = specs
-    @autotest = prepare(autotest)
-    autotest.test_files_for(@file) == specs
-  end
-
-  chain :to do |file|
-    @file = file
-  end
-
-  failure_message_for_should do
-    "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}"
-  end
-
-  def prepare(autotest)
-    find_order = @specs.dup << @file
-    autotest.instance_eval { @find_order = find_order }
-    autotest
-  end
-end
-
-RSpec::Matchers.define :fail_with do |exception_klass|
-  match do |example|
-    failure_reason(example, exception_klass).nil?
-  end
-
-  failure_message_for_should do |example|
-    "expected example to fail with a #{exception_klass} exception, but #{failure_reason(example, exception_klass)}"
-  end
-
-  def failure_reason(example, exception_klass)
-    result = example.metadata[:execution_result]
-    case
-      when example.metadata[:pending] then "was pending"
-      when result[:status] != 'failed' then result[:status]
-      when !result[:exception].is_a?(exception_klass) then "failed with a #{result[:exception].class}"
-      else nil
-    end
-  end
-end
-
-RSpec::Matchers.define :pass do
-  match do |example|
-    failure_reason(example).nil?
-  end
-
-  failure_message_for_should do |example|
-    "expected example to pass, but #{failure_reason(example)}"
-  end
-
-  def failure_reason(example)
-    result = example.metadata[:execution_result]
-    case
-      when example.metadata[:pending] then "was pending"
-      when result[:status] != 'passed' then result[:status]
-      else nil
-    end
-  end
-end
-
-RSpec::Matchers.module_eval do
-  alias_method :have_failed_with, :fail_with
-  alias_method :have_passed, :pass
-end

data/spec/support/mathn_integration_support.rb

@@ -1,12 +0,0 @@
-require 'support/in_sub_process'
-
-module MathnIntegrationSupport
-  include InSubProcess
-
-  def with_mathn_loaded
-    in_sub_process do
-      require 'mathn'
-      yield
-    end
-  end
-end

data/spec/support/sandboxed_mock_space.rb

@@ -1,116 +0,0 @@
-require 'rspec/mocks'
-
-module RSpec
-  module Mocks
-    Space.class_eval do
-      undef print_out_of_example_deprecation
-      def print_out_of_example_deprecation
-        # The simple "are you outside of an example" detection in rspec-mocks
-        # does not properly handle our dog fooding here in rspec core, where we define
-        # example groups and examples from within an example and run them.
-        # As a result, we get `SystemStackError` in a few specs that are mocking
-        # `RSpec.deprecate` and creating nested examples, but we don't care about
-        # this warning here in rspec-core.
-        #
-        # This redefintion silences it.
-      end
-    end
-  end
-
-  module Core
-    # Because rspec-core dog-foods itself, rspec-core's spec suite has
-    # examples that define example groups and examples and run them. The
-    # usual lifetime of an RSpec::Mocks::Proxy is for one example
-    # (the proxy cache gets cleared between each example), but since the
-    # specs in rspec-core's suite sometimes create test doubles and pass
-    # them to examples a spec defines and runs, the test double's proxy
-    # must live beyond the inner example: it must live for the scope
-    # of wherever it got defined. Here we implement the necessary semantics
-    # for rspec-core's specs:
-    #
-    # - #verify_all and #reset_all affect only mocks that were created
-    #   within the current scope.
-    # - Mock proxies live for the duration of the scope in which they are
-    #   created.
-    #
-    # Thus, mock proxies created in an inner example live for only that
-    # example, but mock proxies created in an outer example can be used
-    # in an inner example but will only be reset/verified when the outer
-    # example completes.
-    class SandboxedMockSpace < ::RSpec::Mocks::Space
-      def self.sandboxed
-        orig_space = RSpec::Mocks.space
-        RSpec::Mocks.space = RSpec::Core::SandboxedMockSpace.new
-
-        RSpec::Core::Example.class_eval do
-          alias_method :orig_run, :run
-          def run(*args)
-            RSpec::Mocks.space.sandboxed do
-              orig_run(*args)
-            end
-          end
-        end
-
-        yield
-      ensure
-        RSpec::Core::Example.class_eval do
-          remove_method :run
-          alias_method :run, :orig_run
-          remove_method :orig_run
-        end
-
-        RSpec::Mocks.space = orig_space
-      end
-
-      class Sandbox
-        attr_reader :proxies
-
-        def initialize
-          @proxies = Set.new
-        end
-
-        def verify_all
-          @proxies.each { |p| p.verify }
-        end
-
-        def reset_all
-          @proxies.each { |p| p.reset }
-        end
-      end
-
-      def initialize
-        @sandbox_stack = []
-        super
-      end
-
-      def sandboxed
-        @sandbox_stack << Sandbox.new
-        yield
-      ensure
-        @sandbox_stack.pop
-      end
-
-      def verify_all
-        return super unless sandbox = @sandbox_stack.last
-        sandbox.verify_all
-      end
-
-      def reset_all
-        return super unless sandbox = @sandbox_stack.last
-        sandbox.reset_all
-      end
-
-      def proxy_for(object)
-        new_proxy = !proxies.has_key?(object.__id__)
-        proxy = super
-
-        if new_proxy && sandbox = @sandbox_stack.last
-          sandbox.proxies << proxy
-        end
-
-        proxy
-      end
-    end
-  end
-end
-

data/spec/support/shared_example_groups.rb

@@ -1,42 +0,0 @@
-shared_examples_for "metadata hash builder" do
-  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true" do
-    let(:hash) { metadata_hash(:foo, :bar, :bazz => 23) }
-
-    before(:each) do
-      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
-    end
-
-    it 'treats symbols as metadata keys with a true value' do
-      expect(hash[:foo]).to be(true)
-      expect(hash[:bar]).to be(true)
-    end
-
-    it 'still processes hash values normally' do
-      expect(hash[:bazz]).to be(23)
-    end
-  end
-
-  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false" do
-    let(:warning_receiver) { Kernel }
-
-    before(:each) do
-      allow_deprecation
-      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
-      warning_receiver.stub(:warn)
-    end
-
-    it 'prints a deprecation warning about any symbols given as arguments' do
-      warning_receiver.should_receive(:warn).with(/In RSpec 3, these symbols will be treated as metadata keys/)
-      metadata_hash(:foo, :bar, :key => 'value')
-    end
-
-    it 'does not treat symbols as metadata keys' do
-      expect(metadata_hash(:foo, :bar, :key => 'value')).not_to include(:foo, :bar)
-    end
-
-    it 'does not print a warning if there are no symbol arguments' do
-      warning_receiver.should_not_receive(:warn)
-      metadata_hash(:foo => 23, :bar => 17)
-    end
-  end
-end

data/spec/support/silence_dsl_deprecations.rb

@@ -1,32 +0,0 @@
-module SilenceDSLDeprecations
-  class Reporter
-    def initialize(reporter)
-      @reporter = reporter
-    end
-
-    def deprecation(*)
-      # do nothing
-    end
-
-    def respond_to?(*args)
-      @reporter.respond_to?(*args) || super
-    end
-
-    def method_missing(*args, &block)
-      @reporter.__send__(*args, &block)
-    end
-  end
-
-  def silence_dsl_deprecations
-    old_reporter = RSpec.configuration.reporter
-    replace_reporter(Reporter.new(old_reporter))
-    yield
-  ensure
-    replace_reporter(old_reporter)
-  end
-
-  def replace_reporter(new_reporter)
-    RSpec.configuration.instance_variable_set(:@reporter, new_reporter)
-  end
-end
-

data/spec/support/spec_files.rb

@@ -1,44 +0,0 @@
-shared_context "spec files" do
-  def failing_spec_filename
-    @failing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_failing_spec.rb"
-  end
-
-  def passing_spec_filename
-    @passing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_passing_spec.rb"
-  end
-
-  def create_passing_spec_file
-    File.open(passing_spec_filename, 'w') do |f|
-      f.write %q{
-        describe "passing spec" do
-          it "passes" do
-            expect(1).to eq(1)
-          end
-        end
-      }
-    end
-  end
-
-  def create_failing_spec_file
-    File.open(failing_spec_filename, 'w') do |f|
-      f.write %q{
-        describe "failing spec" do
-          it "fails" do
-            expect(1).to eq(2)
-          end
-        end
-      }
-    end
-  end
-
-  before(:all) do
-    create_passing_spec_file
-    create_failing_spec_file
-  end
-
-  after(:all) do
-    File.delete(passing_spec_filename)
-    File.delete(failing_spec_filename)
-  end
-
-end