rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/core/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Core
     module Version
-      STRING = '3.0.0.beta1'
+      STRING = '3.0.0.beta2'
     end
   end
 end

data/spec/command_line/order_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe 'command line', :ui do
+RSpec.describe 'command line', :ui, :slow do
   let(:stderr) { StringIO.new }
   let(:stdout) { StringIO.new }
 
   before :all do
     write_file 'spec/simple_spec.rb', """
-      describe 'group 1' do
+      RSpec.describe 'group 1' do
         specify('group 1 example 1') {}
         specify('group 1 example 2') {}
         specify('group 1 example 3') {}
@@ -19,7 +19,7 @@ describe 'command line', :ui do
     """
 
     write_file 'spec/simple_spec2.rb', """
-      describe 'group 2' do
+      RSpec.describe 'group 2' do
         specify('group 2 example 1') {}
         specify('group 2 example 2') {}
         specify('group 2 example 3') {}
@@ -32,7 +32,7 @@ describe 'command line', :ui do
     """
 
     write_file 'spec/order_spec.rb', """
-      describe 'group 1' do
+      RSpec.describe 'group 1' do
         specify('group 1 example 1')  {}
         specify('group 1 example 2')  {}
         specify('group 1 example 3')  {}
@@ -68,15 +68,15 @@ describe 'command line', :ui do
         describe('group 1-10') { specify('example') {} }
       end
 
-      describe('group 2')  { specify('example') {} }
-      describe('group 3')  { specify('example') {} }
-      describe('group 4')  { specify('example') {} }
-      describe('group 5')  { specify('example') {} }
-      describe('group 6')  { specify('example') {} }
-      describe('group 7')  { specify('example') {} }
-      describe('group 8')  { specify('example') {} }
-      describe('group 9')  { specify('example') {} }
-      describe('group 10') { specify('example') {} }
+      RSpec.describe('group 2')  { specify('example') {} }
+      RSpec.describe('group 3')  { specify('example') {} }
+      RSpec.describe('group 4')  { specify('example') {} }
+      RSpec.describe('group 5')  { specify('example') {} }
+      RSpec.describe('group 6')  { specify('example') {} }
+      RSpec.describe('group 7')  { specify('example') {} }
+      RSpec.describe('group 8')  { specify('example') {} }
+      RSpec.describe('group 9')  { specify('example') {} }
+      RSpec.describe('group 10') { specify('example') {} }
     """
   end
 
@@ -158,14 +158,14 @@ describe 'command line', :ui do
           end
         end
 
-        describe 'group B' do
+        RSpec.describe 'group B' do
           specify('group B example D')  {}
           specify('group B example B')  {}
           specify('group B example A')  {}
           specify('group B example C')  {}
         end
 
-        describe 'group A' do
+        RSpec.describe 'group A' do
           specify('group A example 1')  {}
         end
       """

data/spec/rspec/core/backtrace_formatter_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 module RSpec::Core
-  describe BacktraceFormatter do
+  RSpec.describe BacktraceFormatter do
     def make_backtrace_formatter(exclusion_patterns=nil, inclusion_patterns=nil)
       BacktraceFormatter.new.tap do |bc|
         bc.exclusion_patterns = exclusion_patterns if exclusion_patterns
@@ -93,6 +93,20 @@ module RSpec::Core
           expect(BacktraceFormatter.new.format_backtrace(backtrace).drop(4).join).to match(/Showing full backtrace/)
         end
       end
+
+      context "when rspec is installed in the current working directory" do
+        it "excludes lines from rspec libs by default", :unless => RSpec.windows_os? do
+          backtrace = [
+            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
+            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
+            "#{Dir.getwd}/my_spec.rb:5",
+            "#{Dir.getwd}/.bundle/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
+            "#{Dir.getwd}/.bundle/path/to/rspec-core/lib/rspec/core/foo.rb:37"
+          ]
+
+          expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./my_spec.rb:5"])
+        end
+      end
     end
 
     describe "#full_backtrace=true" do

data/spec/rspec/core/command_line_spec.rb

@@ -3,25 +3,28 @@ require "stringio"
 require 'tmpdir'
 
 module RSpec::Core
-  describe CommandLine do
+  RSpec.describe CommandLine do
 
     let(:out)    { StringIO.new         }
     let(:err)    { StringIO.new         }
     let(:config) { RSpec::configuration }
     let(:world)  { RSpec::world         }
 
-    before { config.stub :run_hook }
+    before do
+      allow(config.hooks).to receive(:run)
+    end
 
     it "configures streams before command line options" do
+      allow(RSpec).to receive(:deprecate)  # remove this and should_receive when ordered
       stdout = StringIO.new
-      config.stub :load_spec_files
-      config.stub(:reporter => double.as_null_object)
+      allow(config).to receive(:load_spec_files)
+      allow(config).to receive(:reporter).and_return(double.as_null_object)
       config.output_stream = $stdout
 
       # this is necessary to ensure that color works correctly on windows
-      config.should_receive(:error_stream=).ordered
-      config.should_receive(:output_stream=).ordered
-      config.should_receive(:force).at_least(:once).ordered
+      expect(config).to receive(:error_stream=).ordered
+      expect(config).to receive(:output_stream=).ordered
+      expect(config).to receive(:force).at_least(:once).ordered
 
       command_line = build_command_line
       command_line.run err, stdout
@@ -30,7 +33,7 @@ module RSpec::Core
     it "assigns ConfigurationOptions built from Array of options to @options" do
       config_options = ConfigurationOptions.new(%w[--color])
       command_line   = CommandLine.new(%w[--color])
-      expect(command_line.instance_eval { @options.options }).to eq(config_options.parse_options)
+      expect(command_line.instance_eval { @options.options }).to eq(config_options.options)
     end
 
     it "assigns submitted ConfigurationOptions to @options" do
@@ -60,23 +63,23 @@ module RSpec::Core
       end
 
       context "running hooks" do
-        before { config.stub :load_spec_files }
+        before { allow(config).to receive :load_spec_files }
 
         it "runs before suite hooks" do
-          config.should_receive(:run_hook).with(:before, :suite)
+          expect(config.hooks).to receive(:run).with(:before, :suite)
           command_line = build_command_line
           command_line.run err, out
         end
 
         it "runs after suite hooks" do
-          config.should_receive(:run_hook).with(:after, :suite)
+          expect(config.hooks).to receive(:run).with(:after, :suite)
           command_line = build_command_line
           command_line.run err, out
         end
 
         it "runs after suite hooks even after an error" do
-          config.should_receive(:run_hook).with(:before, :suite).and_raise "this error"
-          config.should_receive(:run_hook).with(:after , :suite)
+          expect(config.hooks).to receive(:run).with(:before, :suite).and_raise "this error"
+          expect(config.hooks).to receive(:run).with(:after , :suite)
           expect do
             command_line = build_command_line
             command_line.run err, out
@@ -86,7 +89,7 @@ module RSpec::Core
     end
 
     describe "#run with custom output" do
-      before { config.stub :files_to_run => [] }
+      before { allow(config).to receive_messages :files_to_run => [] }
 
       let(:output_file) { File.new("#{Dir.tmpdir}/command_line_spec_output.txt", 'w') }
 
@@ -103,9 +106,7 @@ module RSpec::Core
     end
 
     def build_config_options *args
-      options = ConfigurationOptions.new args
-      options.parse_options
-      options
+      ConfigurationOptions.new args
     end
   end
 end

data/spec/rspec/core/configuration_options_spec.rb

@@ -2,74 +2,92 @@ require 'spec_helper'
 require 'ostruct'
 require 'rspec/core/drb_options'
 
-describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolated_home => true do
+RSpec.describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolated_home => true do
   include ConfigOptionsHelper
 
   it "warns when HOME env var is not set", :unless => (RUBY_PLATFORM == 'java') do
     without_env_vars 'HOME' do
       expect_warning_with_call_site(__FILE__, __LINE__ + 1)
-      RSpec::Core::ConfigurationOptions.new([]).parse_options
+      RSpec::Core::ConfigurationOptions.new([]).options
     end
   end
 
-  it "duplicates the arguments array" do
+  it "does not mutate the provided args array" do
     args = ['-e', 'some spec']
-    coo = RSpec::Core::ConfigurationOptions.new(args)
-    coo.parse_options
+    RSpec::Core::ConfigurationOptions.new(args).options
     expect(args).to eq(['-e', 'some spec'])
   end
 
   describe "#configure" do
+    let(:config) { RSpec::Core::Configuration.new }
+
     it "sends libs before requires" do
       opts = config_options_object(*%w[--require a/path -I a/lib])
       config = double("config").as_null_object
-      config.should_receive(:libs=).ordered
-      config.should_receive(:setup_load_path_and_require).ordered
+      expect(config).to receive(:libs=).ordered
+      expect(config).to receive(:requires=).ordered
       opts.configure(config)
     end
 
-    it "sends loads requires before loading specs" do
+    it "loads requires before loading specs" do
       opts = config_options_object(*%w[-rspec_helper])
-      config = double("config").as_null_object
-      expect(config).to receive(:setup_load_path_and_require).ordered
-      expect(config).to receive(:files_or_directories_to_run=).ordered
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:requires=).ordered
+      expect(config).to receive(:get_files_to_run).ordered
       opts.configure(config)
+      config.files_to_run
     end
 
     it "sets up load path and requires before formatter" do
       opts = config_options_object(*%w[--require a/path -f a/formatter])
       config = double("config").as_null_object
-      config.should_receive(:setup_load_path_and_require).ordered
-      config.should_receive(:add_formatter).ordered
+      expect(config).to receive(:requires=).ordered
+      expect(config).to receive(:add_formatter).ordered
       opts.configure(config)
     end
 
-    it "sends default_path before files_or_directories_to_run" do
+    it "sets default_path before loading specs" do
       opts = config_options_object(*%w[--default_path spec])
-      config = double("config").as_null_object
-      config.should_receive(:force).with(:default_path => 'spec').ordered
-      config.should_receive(:files_or_directories_to_run=).ordered
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:force).with(:default_path => 'spec').ordered
+      expect(config).to receive(:get_files_to_run).ordered
+      opts.configure(config)
+      config.files_to_run
+    end
+
+    it "sets `files_or_directories_to_run` before `requires` so users can check `files_to_run` in a spec_helper loaded by `--require`" do
+      opts = config_options_object(*%w[--require spec_helper])
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:files_or_directories_to_run=).ordered
+      expect(config).to receive(:requires=).ordered
+      opts.configure(config)
+    end
+
+    it "sets default_path before `files_or_directories_to_run` since it relies on it" do
+      opts = config_options_object(*%w[--default_path spec])
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:force).with(:default_path => 'spec').ordered
+      expect(config).to receive(:files_or_directories_to_run=).ordered
       opts.configure(config)
     end
 
-    it "sends pattern before files_or_directories_to_run" do
+    it "sets pattern before loading specs" do
       opts = config_options_object(*%w[--pattern **/*.spec])
-      config = double("config").as_null_object
-      config.should_receive(:force).with(:pattern => '**/*.spec').ordered
-      config.should_receive(:files_or_directories_to_run=).ordered
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:force).with(:pattern => '**/*.spec').ordered
+      expect(config).to receive(:get_files_to_run).ordered
       opts.configure(config)
+      config.files_to_run
     end
 
     it "assigns inclusion_filter" do
       opts = config_options_object(*%w[--tag awesome])
-      config = RSpec::Core::Configuration.new
       opts.configure(config)
       expect(config.inclusion_filter).to have_key(:awesome)
     end
 
     it "merges the :exclusion_filter option with the default exclusion_filter" do
       opts = config_options_object(*%w[--tag ~slow])
-      config = RSpec::Core::Configuration.new
       opts.configure(config)
       expect(config.exclusion_filter).to have_key(:slow)
     end
@@ -77,7 +95,7 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
     it "forces color_enabled" do
       opts = config_options_object(*%w[--color])
       config = RSpec::Core::Configuration.new
-      config.should_receive(:force).with(:color => true)
+      expect(config).to receive(:force).with(:color => true)
       opts.configure(config)
     end
 
@@ -93,7 +111,7 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
       it "forces #{config_key}" do
         opts = config_options_object(cli_option, cli_value)
         config = RSpec::Core::Configuration.new
-        config.should_receive(:force) do |pair|
+        expect(config).to receive(:force) do |pair|
           expect(pair.keys.first).to eq(config_key)
           expect(pair.values.first).to eq(config_value)
         end
@@ -104,9 +122,8 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
     it "merges --require specified by multiple configuration sources" do
       with_env_vars 'SPEC_OPTS' => "--require file_from_env" do
         opts = config_options_object(*%w[--require file_from_opts])
-        config = RSpec::Core::Configuration.new
-        config.should_receive(:require).with("file_from_opts")
-        config.should_receive(:require).with("file_from_env")
+        expect(config).to receive(:require).with("file_from_opts")
+        expect(config).to receive(:require).with("file_from_env")
         opts.configure(config)
       end
     end
@@ -114,8 +131,7 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
     it "merges --I specified by multiple configuration sources" do
       with_env_vars 'SPEC_OPTS' => "-I dir_from_env" do
         opts = config_options_object(*%w[-I dir_from_opts])
-        config = RSpec::Core::Configuration.new
-        config.should_receive(:libs=).with(["dir_from_opts", "dir_from_env"])
+        expect(config).to receive(:libs=).with(["dir_from_opts", "dir_from_env"])
         opts.configure(config)
       end
     end
@@ -295,19 +311,26 @@ describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolat
       )
     end
 
+    it "parses file names that look like options line-number and default-path" do
+      expect(parse_options("spec/default_path_spec.rb", "spec/line_number_spec.rb")).to include(
+        :files_or_directories_to_run => ["spec/default_path_spec.rb", "spec/line_number_spec.rb"]
+      )
+    end
+
     it "provides no files or directories if spec directory does not exist" do
-      FileTest.stub(:directory?).with("spec").and_return false
+      allow(FileTest).to receive(:directory?).with("spec").and_return false
       expect(parse_options()).to include(:files_or_directories_to_run => [])
     end
   end
 
   describe "default_path" do
     it "gets set before files_or_directories_to_run" do
-      config = double("config").as_null_object
-      config.should_receive(:force).with(:default_path => 'foo').ordered
-      config.should_receive(:files_or_directories_to_run=).ordered
+      config = RSpec::Core::Configuration.new
+      expect(config).to receive(:force).with(:default_path => 'foo').ordered
+      expect(config).to receive(:get_files_to_run).ordered
       opts = config_options_object("--default_path", "foo")
       opts.configure(config)
+      config.files_to_run
     end
   end
 

data/spec/rspec/core/configuration_spec.rb

@@ -3,19 +3,10 @@ require 'tmpdir'
 
 module RSpec::Core
 
-  describe Configuration do
+  RSpec.describe Configuration do
 
     let(:config) { Configuration.new }
 
-    describe "RSpec.configuration with a block" do
-      before { RSpec.stub(:warn_deprecation) }
-
-      it "is deprecated" do
-        RSpec.should_receive(:warn_deprecation)
-        RSpec.configuration {}
-      end
-    end
-
     describe '#deprecation_stream' do
       it 'defaults to standard error' do
         expect($rspec_core_without_stderr_monkey_patch.deprecation_stream).to eq STDERR
@@ -62,7 +53,7 @@ module RSpec::Core
       end
     end
 
-    describe "#setup_load_path_and_require" do
+    describe "#requires=" do
       include_context "isolate load path mutation"
 
       def absolute_path_to(dir)
@@ -74,7 +65,7 @@ module RSpec::Core
         $LOAD_PATH.delete(lib_dir)
 
         expect($LOAD_PATH).not_to include(lib_dir)
-        config.setup_load_path_and_require []
+        config.requires = []
         expect($LOAD_PATH).to include(lib_dir)
       end
 
@@ -83,20 +74,20 @@ module RSpec::Core
         foo_dir = absolute_path_to("features")
 
         expect($LOAD_PATH).not_to include(foo_dir)
-        config.setup_load_path_and_require []
+        config.requires = []
         expect($LOAD_PATH).to include(foo_dir)
       end
 
       it 'stores the required files' do
-        config.should_receive(:require).with('a/path')
-        config.setup_load_path_and_require ['a/path']
+        expect(config).to receive(:require).with('a/path')
+        config.requires = ['a/path']
         expect(config.requires).to eq ['a/path']
       end
 
       context "when `default_path` refers to a file rather than a directory" do
         it 'does not add it to the load path' do
           config.default_path = 'Rakefile'
-          config.setup_load_path_and_require []
+          config.requires = []
           expect($LOAD_PATH).not_to include(match(/Rakefile/))
         end
       end
@@ -105,27 +96,27 @@ module RSpec::Core
     describe "#load_spec_files" do
       it "loads files using load" do
         config.files_to_run = ["foo.bar", "blah_spec.rb"]
-        config.should_receive(:load).twice
+        expect(config).to receive(:load).twice
         config.load_spec_files
       end
 
       it "loads each file once, even if duplicated in list" do
         config.files_to_run = ["a_spec.rb", "a_spec.rb"]
-        config.should_receive(:load).once
+        expect(config).to receive(:load).once
         config.load_spec_files
       end
     end
 
     describe "#mock_framework" do
       it "defaults to :rspec" do
-        config.should_receive(:require).with('rspec/core/mocking/with_rspec')
+        expect(config).to receive(:require).with('rspec/core/mocking_adapters/rspec')
         config.mock_framework
       end
     end
 
     describe "#mock_framework="do
       it "delegates to mock_with" do
-        config.should_receive(:mock_with).with(:rspec)
+        expect(config).to receive(:mock_with).with(:rspec)
         config.mock_framework = :rspec
       end
     end
@@ -134,7 +125,7 @@ module RSpec::Core
       it "yields a config object if the framework_module supports it" do
         custom_config = Struct.new(:custom_setting).new
         mod = Module.new
-        mod.stub(:configuration => custom_config)
+        allow(mod).to receive_messages(:configuration => custom_config)
 
         config.send m, mod do |mod_config|
           mod_config.custom_setting = true
@@ -154,23 +145,14 @@ module RSpec::Core
     end
 
     describe "#mock_with" do
-      before { config.stub(:require) }
+      before { allow(config).to receive(:require) }
 
       it_behaves_like "a configurable framework adapter", :mock_with
 
-      [:rspec, :mocha, :rr, :flexmock].each do |framework|
-        context "with #{framework}" do
-          it "requires the adapter for #{framework}" do
-            config.should_receive(:require).with("rspec/core/mocking/with_#{framework}")
-            config.mock_with framework
-          end
-        end
-      end
-
       it "allows rspec-mocks to be configured with a provided block" do
         mod = Module.new
 
-        RSpec::Mocks.configuration.should_receive(:add_stub_and_should_receive_to).with(mod)
+        expect(RSpec::Mocks.configuration).to receive(:add_stub_and_should_receive_to).with(mod)
 
         config.mock_with :rspec do |c|
           c.add_stub_and_should_receive_to mod
@@ -185,14 +167,33 @@ module RSpec::Core
         end
       end
 
-      it "uses the null adapter when set to any unknown key" do
-        config.should_receive(:require).with('rspec/core/mocking/with_absolutely_nothing')
-        config.mock_with :crazy_new_mocking_framework_ive_not_yet_heard_of
+      it 'uses the named adapter' do
+        expect(config).to receive(:require).with("rspec/core/mocking_adapters/mocha")
+        stub_const("RSpec::Core::MockingAdapters::Mocha", Module.new)
+        config.mock_with :mocha
+      end
+
+      it "uses the null adapter when given :nothing" do
+        expect(config).to receive(:require).with('rspec/core/mocking_adapters/null').and_call_original
+        config.mock_with :nothing
+      end
+
+      it "raises an error when given an unknown key" do
+        expect {
+          config.mock_with :crazy_new_mocking_framework_ive_not_yet_heard_of
+        }.to raise_error(ArgumentError, /unknown mocking framework/i)
+      end
+
+      it "raises an error when given another type of object" do
+        expect {
+          config.mock_with Object.new
+        }.to raise_error(ArgumentError, /unknown mocking framework/i)
       end
 
       context 'when there are already some example groups defined' do
         it 'raises an error since this setting must be applied before any groups are defined' do
-          RSpec.world.stub(:example_groups).and_return([double.as_null_object])
+          allow(RSpec.world).to receive(:example_groups).and_return([double.as_null_object])
+          stub_const("RSpec::Core::MockingAdapters::Mocha", double(:framework_name => :mocha))
           expect {
             config.mock_with :mocha
           }.to raise_error(/must be configured before any example groups are defined/)
@@ -200,13 +201,14 @@ module RSpec::Core
 
         it 'does not raise an error if the default `mock_with :rspec` is re-configured' do
           config.mock_framework # called by RSpec when configuring the first example group
-          RSpec.world.stub(:example_groups).and_return([double.as_null_object])
+          allow(RSpec.world).to receive(:example_groups).and_return([double.as_null_object])
           config.mock_with :rspec
         end
 
         it 'does not raise an error if re-setting the same config' do
+          stub_const("RSpec::Core::MockingAdapters::Mocha", double(:framework_name => :mocha))
           groups = []
-          RSpec.world.stub(:example_groups => groups)
+          allow(RSpec.world).to receive_messages(:example_groups => groups)
           config.mock_with :mocha
           groups << double.as_null_object
           config.mock_with :mocha
@@ -216,14 +218,14 @@ module RSpec::Core
 
     describe "#expectation_framework" do
       it "defaults to :rspec" do
-        config.should_receive(:require).with('rspec/expectations')
+        expect(config).to receive(:require).with('rspec/expectations')
         config.expectation_frameworks
       end
     end
 
     describe "#expectation_framework=" do
       it "delegates to expect_with=" do
-        config.should_receive(:expect_with).with(:rspec)
+        expect(config).to receive(:expect_with).with(:rspec)
         config.expectation_framework = :rspec
       end
     end
@@ -231,7 +233,7 @@ module RSpec::Core
     describe "#expect_with" do
       before do
         stub_const("Test::Unit::Assertions", Module.new)
-        config.stub(:require)
+        allow(config).to receive(:require)
       end
 
       it_behaves_like "a configurable framework adapter", :expect_with
@@ -242,7 +244,7 @@ module RSpec::Core
       ].each do |framework, required_file|
         context "with #{framework}" do
           it "requires #{required_file}" do
-            config.should_receive(:require).with(required_file)
+            expect(config).to receive(:require).with(required_file)
             config.expect_with framework
           end
         end
@@ -269,7 +271,7 @@ module RSpec::Core
 
       context 'when there are already some example groups defined' do
         it 'raises an error since this setting must be applied before any groups are defined' do
-          RSpec.world.stub(:example_groups).and_return([double.as_null_object])
+          allow(RSpec.world).to receive(:example_groups).and_return([double.as_null_object])
           expect {
             config.expect_with :rspec
           }.to raise_error(/must be configured before any example groups are defined/)
@@ -277,13 +279,13 @@ module RSpec::Core
 
         it 'does not raise an error if the default `expect_with :rspec` is re-configured' do
           config.expectation_frameworks # called by RSpec when configuring the first example group
-          RSpec.world.stub(:example_groups).and_return([double.as_null_object])
+          allow(RSpec.world).to receive(:example_groups).and_return([double.as_null_object])
           config.expect_with :rspec
         end
 
         it 'does not raise an error if re-setting the same config' do
           groups = []
-          RSpec.world.stub(:example_groups => groups)
+          allow(RSpec.world).to receive_messages(:example_groups => groups)
           config.expect_with :stdlib
           groups << double.as_null_object
           config.expect_with :stdlib
@@ -294,7 +296,7 @@ module RSpec::Core
     describe "#expecting_with_rspec?" do
       before do
         stub_const("Test::Unit::Assertions", Module.new)
-        config.stub(:require)
+        allow(config).to receive(:require)
       end
 
       it "returns false by default" do
@@ -324,26 +326,36 @@ module RSpec::Core
 
     describe "#files_to_run" do
       it "loads files not following pattern if named explicitly" do
-        config.files_or_directories_to_run = "spec/rspec/core/resources/a_bar.rb"
+        assign_files_or_directories_to_run "spec/rspec/core/resources/a_bar.rb"
         expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_bar.rb"])
       end
 
       it "prevents repetition of dir when start of the pattern" do
         config.pattern = "spec/**/a_spec.rb"
-        config.files_or_directories_to_run = "spec"
+        assign_files_or_directories_to_run "spec"
         expect(config.files_to_run).to eq(["spec/rspec/core/resources/a_spec.rb"])
       end
 
       it "does not prevent repetition of dir when later of the pattern" do
         config.pattern = "rspec/**/a_spec.rb"
-        config.files_or_directories_to_run = "spec"
+        assign_files_or_directories_to_run "spec"
         expect(config.files_to_run).to eq(["spec/rspec/core/resources/a_spec.rb"])
       end
 
+      it 'reloads when `files_or_directories_to_run` is reassigned' do
+        config.pattern = "spec/**/a_spec.rb"
+        config.files_or_directories_to_run = "empty_dir"
+
+        expect {
+          config.files_or_directories_to_run = "spec"
+        }.to change { config.files_to_run }.
+          to(["spec/rspec/core/resources/a_spec.rb"])
+      end
+
       context "with <path>:<line_number>" do
         it "overrides inclusion filters set on config" do
           config.filter_run_including :foo => :bar
-          config.files_or_directories_to_run = "path/to/file.rb:37"
+          assign_files_or_directories_to_run "path/to/file.rb:37"
           expect(config.inclusion_filter.size).to eq(1)
           expect(config.inclusion_filter[:locations].keys.first).to match(/path\/to\/file\.rb$/)
           expect(config.inclusion_filter[:locations].values.first).to eq([37])
@@ -351,7 +363,7 @@ module RSpec::Core
 
         it "overrides inclusion filters set before config" do
           config.force(:inclusion_filter => {:foo => :bar})
-          config.files_or_directories_to_run = "path/to/file.rb:37"
+          assign_files_or_directories_to_run "path/to/file.rb:37"
           expect(config.inclusion_filter.size).to eq(1)
           expect(config.inclusion_filter[:locations].keys.first).to match(/path\/to\/file\.rb$/)
           expect(config.inclusion_filter[:locations].values.first).to eq([37])
@@ -359,14 +371,14 @@ module RSpec::Core
 
         it "clears exclusion filters set on config" do
           config.exclusion_filter = { :foo => :bar }
-          config.files_or_directories_to_run = "path/to/file.rb:37"
+          assign_files_or_directories_to_run "path/to/file.rb:37"
           expect(config.exclusion_filter).to be_empty,
             "expected exclusion filter to be empty:\n#{config.exclusion_filter}"
         end
 
         it "clears exclusion filters set before config" do
           config.force(:exclusion_filter => { :foo => :bar })
-          config.files_or_directories_to_run = "path/to/file.rb:37"
+          assign_files_or_directories_to_run "path/to/file.rb:37"
           expect(config.exclusion_filter).to be_empty,
             "expected exclusion filter to be empty:\n#{config.exclusion_filter}"
         end
@@ -374,51 +386,53 @@ module RSpec::Core
 
       context "with default pattern" do
         it "loads files named _spec.rb" do
-          config.files_or_directories_to_run = "spec/rspec/core/resources"
+          assign_files_or_directories_to_run "spec/rspec/core/resources"
           expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_spec.rb"])
         end
 
         it "loads files in Windows", :if => RSpec.windows_os? do
-          config.files_or_directories_to_run = "C:\\path\\to\\project\\spec\\sub\\foo_spec.rb"
+          assign_files_or_directories_to_run "C:\\path\\to\\project\\spec\\sub\\foo_spec.rb"
           expect(config.files_to_run).to eq([      "C:/path/to/project/spec/sub/foo_spec.rb"])
         end
 
         it "loads files in Windows when directory is specified", :if => RSpec.windows_os? do
-          config.files_or_directories_to_run = "spec\\rspec\\core\\resources"
+          assign_files_or_directories_to_run "spec\\rspec\\core\\resources"
           expect(config.files_to_run).to eq([      "spec/rspec/core/resources/a_spec.rb"])
         end
       end
 
       context "with default default_path" do
         it "loads files in the default path when run by rspec" do
-          config.stub(:command) { 'rspec' }
-          config.files_or_directories_to_run = []
+          allow(config).to receive(:command) { 'rspec' }
+          assign_files_or_directories_to_run []
           expect(config.files_to_run).not_to be_empty
         end
 
         it "loads files in the default path when run with DRB (e.g., spork)" do
-          config.stub(:command) { 'spork' }
-          RSpec::Core::Runner.stub(:running_in_drb?) { true }
-          config.files_or_directories_to_run = []
+          allow(config).to receive(:command) { 'spork' }
+          allow(RSpec::Core::Runner).to receive(:running_in_drb?) { true }
+          assign_files_or_directories_to_run []
           expect(config.files_to_run).not_to be_empty
         end
 
         it "does not load files in the default path when run by ruby" do
-          config.stub(:command) { 'ruby' }
-          config.files_or_directories_to_run = []
+          allow(config).to receive(:command) { 'ruby' }
+          assign_files_or_directories_to_run []
           expect(config.files_to_run).to be_empty
         end
       end
 
       def specify_consistent_ordering_of_files_to_run
-        File.stub(:directory?).with('a') { true }
+        allow(File).to receive(:directory?).with('a') { true }
+        globbed_files = nil
+        allow(Dir).to receive(:[]).with(/^\{?a/) { globbed_files }
 
         orderings = [
           %w[ a/1.rb a/2.rb a/3.rb ],
           %w[ a/2.rb a/1.rb a/3.rb ],
           %w[ a/3.rb a/2.rb a/1.rb ]
         ].map do |files|
-          Dir.should_receive(:[]).with(/^\{?a/) { files }
+          globbed_files = files
           yield
           config.files_to_run
         end
@@ -430,7 +444,7 @@ module RSpec::Core
         it 'orders the files in a consistent ordering, regardless of the underlying OS ordering' do
           specify_consistent_ordering_of_files_to_run do
             config.pattern = 'a/*.rb'
-            config.files_or_directories_to_run = 'a'
+            assign_files_or_directories_to_run 'a'
           end
         end
       end
@@ -439,20 +453,20 @@ module RSpec::Core
         it 'orders the files in a consistent ordering, regardless of the underlying OS ordering' do
           specify_consistent_ordering_of_files_to_run do
             config.pattern = '*.rb'
-            config.files_or_directories_to_run = 'a'
+            assign_files_or_directories_to_run 'a'
           end
         end
       end
 
       context 'when given multiple file paths' do
         it 'orders the files in a consistent ordering, regardless of the given order' do
-          File.stub(:directory?) { false } # fake it into thinking these a full file paths
+          allow(File).to receive(:directory?) { false } # fake it into thinking these a full file paths
 
           files = ['a/b/c_spec.rb', 'c/b/a_spec.rb']
-          config.files_or_directories_to_run = *files
+          assign_files_or_directories_to_run(*files)
           ordering_1 = config.files_to_run
 
-          config.files_or_directories_to_run = *(files.reverse)
+          assign_files_or_directories_to_run(*files.reverse)
           ordering_2 = config.files_to_run
 
           expect(ordering_1).to eq(ordering_2)
@@ -466,19 +480,19 @@ module RSpec::Core
           before { config.send(setter, "**/*_foo.rb") }
           it "loads files following pattern" do
             file = File.expand_path(File.dirname(__FILE__) + "/resources/a_foo.rb")
-            config.files_or_directories_to_run = file
+            assign_files_or_directories_to_run file
             expect(config.files_to_run).to include(file)
           end
 
           it "loads files in directories following pattern" do
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
-            config.files_or_directories_to_run = dir
+            assign_files_or_directories_to_run dir
             expect(config.files_to_run).to include("#{dir}/a_foo.rb")
           end
 
           it "does not load files in directories not following pattern" do
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
-            config.files_or_directories_to_run = dir
+            assign_files_or_directories_to_run dir
             expect(config.files_to_run).not_to include("#{dir}/a_bar.rb")
           end
         end
@@ -487,7 +501,7 @@ module RSpec::Core
           it "supports comma separated values" do
             config.send(setter, "**/*_foo.rb,**/*_bar.rb")
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
-            config.files_or_directories_to_run = dir
+            assign_files_or_directories_to_run dir
             expect(config.files_to_run).to include("#{dir}/a_foo.rb")
             expect(config.files_to_run).to include("#{dir}/a_bar.rb")
           end
@@ -495,7 +509,7 @@ module RSpec::Core
           it "supports comma separated values with spaces" do
             config.send(setter, "**/*_foo.rb, **/*_bar.rb")
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
-            config.files_or_directories_to_run = dir
+            assign_files_or_directories_to_run dir
             expect(config.files_to_run).to include("#{dir}/a_foo.rb")
             expect(config.files_to_run).to include("#{dir}/a_bar.rb")
           end
@@ -503,7 +517,7 @@ module RSpec::Core
           it "supports curly braces glob syntax" do
             config.send(setter, "**/*_{foo,bar}.rb")
             dir = File.expand_path(File.dirname(__FILE__) + "/resources")
-            config.files_or_directories_to_run = dir
+            assign_files_or_directories_to_run dir
             expect(config.files_to_run).to include("#{dir}/a_foo.rb")
             expect(config.files_to_run).to include("#{dir}/a_bar.rb")
           end
@@ -528,7 +542,7 @@ module RSpec::Core
 
     describe "path with line number" do
       it "assigns the line number as a location filter" do
-        config.files_or_directories_to_run = "path/to/a_spec.rb:37"
+        assign_files_or_directories_to_run "path/to/a_spec.rb:37"
         expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
       end
     end
@@ -554,25 +568,25 @@ module RSpec::Core
 
     context "with line number" do
       it "assigns the file and line number as a location filter" do
-        config.files_or_directories_to_run = "path/to/a_spec.rb:37"
+        assign_files_or_directories_to_run "path/to/a_spec.rb:37"
         expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37]}})
       end
 
       it "assigns multiple files with line numbers as location filters" do
-        config.files_or_directories_to_run = "path/to/a_spec.rb:37", "other_spec.rb:44"
+        assign_files_or_directories_to_run "path/to/a_spec.rb:37", "other_spec.rb:44"
         expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37],
                                                 File.expand_path("other_spec.rb") => [44]}})
       end
 
       it "assigns files with multiple line numbers as location filters" do
-        config.files_or_directories_to_run = "path/to/a_spec.rb:37", "path/to/a_spec.rb:44"
+        assign_files_or_directories_to_run "path/to/a_spec.rb:37", "path/to/a_spec.rb:44"
         expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [37, 44]}})
       end
     end
 
     context "with multiple line numbers" do
       it "assigns the file and line numbers as a location filter" do
-        config.files_or_directories_to_run = "path/to/a_spec.rb:1:3:5:7"
+        assign_files_or_directories_to_run "path/to/a_spec.rb:1:3:5:7"
         expect(config.filter).to eq({:locations => {File.expand_path("path/to/a_spec.rb") => [1,3,5,7]}})
       end
     end
@@ -687,7 +701,7 @@ module RSpec::Core
               config.output_stream = output
 
               config.tty = true
-              config.output_stream.stub :tty? => true
+              allow(config.output_stream).to receive_messages :tty? => true
 
               expect(config.send(color_option)).to be_truthy
               expect(config.send(color_option, output)).to be_truthy
@@ -700,7 +714,7 @@ module RSpec::Core
               config.output_stream = output
 
               config.tty = true
-              config.output_stream.stub :tty? => false
+              allow(config.output_stream).to receive_messages :tty? => false
 
               expect(config.send(color_option)).to be_truthy
               expect(config.send(color_option, output)).to be_truthy
@@ -713,7 +727,7 @@ module RSpec::Core
               config.output_stream = output
 
               config.tty = false
-              config.output_stream.stub :tty? => true
+              allow(config.output_stream).to receive_messages :tty? => true
 
               expect(config.send(color_option)).to be_truthy
               expect(config.send(color_option, output)).to be_truthy
@@ -726,7 +740,7 @@ module RSpec::Core
               config.output_stream = output
 
               config.tty = false
-              config.output_stream.stub :tty? => false
+              allow(config.output_stream).to receive_messages :tty? => false
 
               expect(config.send(color_option)).to be_falsey
               expect(config.send(color_option, output)).to be_falsey
@@ -737,7 +751,7 @@ module RSpec::Core
             before do
               @original_host  = RbConfig::CONFIG['host_os']
               RbConfig::CONFIG['host_os'] = 'mingw'
-              config.stub(:require)
+              allow(config).to receive(:require)
             end
 
             after do
@@ -749,14 +763,14 @@ module RSpec::Core
 
               it "enables colors" do
                 config.output_stream = StringIO.new
-                config.output_stream.stub :tty? => true
+                allow(config.output_stream).to receive_messages :tty? => true
                 config.send "#{color_option}=", true
                 expect(config.send(color_option)).to be_truthy
               end
 
               it "leaves output stream intact" do
                 config.output_stream = $stdout
-                config.stub(:require) do |what|
+                allow(config).to receive(:require) do |what|
                   config.output_stream = 'foo' if what =~ /Win32/
                 end
                 config.send "#{color_option}=", true
@@ -770,13 +784,13 @@ module RSpec::Core
               end
 
               it "warns to install ANSICON" do
-                config.stub(:require) { raise LoadError }
+                allow(config).to receive(:require) { raise LoadError }
                 expect_warning_with_call_site(__FILE__, __LINE__ + 1, /You must use ANSICON/)
                 config.send "#{color_option}=", true
               end
 
               it "sets color_enabled to false" do
-                config.stub(:require) { raise LoadError }
+                allow(config).to receive(:require) { raise LoadError }
                 config.send "#{color_option}=", true
                 config.color_enabled = true
                 expect(config.send(color_option)).to be_falsey
@@ -788,78 +802,18 @@ module RSpec::Core
 
       it "prefers incoming cli_args" do
         config.output_stream = StringIO.new
-        config.output_stream.stub :tty? => true
+        allow(config.output_stream).to receive_messages :tty? => true
         config.force :color => true
         config.color = false
         expect(config.color).to be_truthy
       end
     end
 
-    describe '#formatter=' do
-      it "delegates to add_formatter (better API for user-facing configuration)" do
-        config.should_receive(:add_formatter).with('these','options')
-        config.add_formatter('these','options')
-      end
-    end
-
-    describe "#add_formatter" do
-
-      it "adds to the list of formatters" do
-        config.add_formatter :documentation
-        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
-      end
-
-      it "finds a formatter by name (w/ Symbol)" do
-        config.add_formatter :documentation
-        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
-      end
-
-      it "finds a formatter by name (w/ String)" do
-        config.add_formatter 'documentation'
-        expect(config.formatters.first).to be_an_instance_of(Formatters::DocumentationFormatter)
-      end
-
-      it "finds a formatter by class" do
-        formatter_class = Class.new(Formatters::BaseTextFormatter)
-        config.add_formatter formatter_class
-        expect(config.formatters.first).to be_an_instance_of(formatter_class)
-      end
-
-      it "finds a formatter by class name" do
-        stub_const("CustomFormatter", Class.new(Formatters::BaseFormatter))
-        config.add_formatter "CustomFormatter"
-        expect(config.formatters.first).to be_an_instance_of(CustomFormatter)
-      end
-
-      it "finds a formatter by class fully qualified name" do
-        stub_const("RSpec::CustomFormatter", Class.new(Formatters::BaseFormatter))
-        config.add_formatter "RSpec::CustomFormatter"
-        expect(config.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
-      end
-
-      it "requires a formatter file based on its fully qualified name" do
-        config.should_receive(:require).with('rspec/custom_formatter') do
-          stub_const("RSpec::CustomFormatter", Class.new(Formatters::BaseFormatter))
-        end
-        config.add_formatter "RSpec::CustomFormatter"
-        expect(config.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
-      end
-
-      it "raises NameError if class is unresolvable" do
-        config.should_receive(:require).with('rspec/custom_formatter3')
-        expect(lambda { config.add_formatter "RSpec::CustomFormatter3" }).to raise_error(NameError)
-      end
-
-      it "raises ArgumentError if formatter is unknown" do
-        expect(lambda { config.add_formatter :progresss }).to raise_error(ArgumentError)
-      end
-
-      context "with a 2nd arg defining the output" do
-        it "creates a file at that path and sets it as the output" do
-          path = File.join(Dir.tmpdir, 'output.txt')
-          config.add_formatter('doc', path)
-          expect(config.formatters.first.output).to be_a(File)
-          expect(config.formatters.first.output.path).to eq(path)
+    %w[formatter= add_formatter].each do |config_method|
+      describe "##{config_method}" do
+        it "delegates to formatters#add" do
+          expect(config.formatter_loader).to receive(:add).with('these','options')
+          config.send(config_method,'these','options')
         end
       end
     end
@@ -1065,7 +1019,7 @@ module RSpec::Core
       include_context "isolate load path mutation"
 
       it "adds directories to the LOAD_PATH" do
-        $LOAD_PATH.should_receive(:unshift).with("a/dir")
+        expect($LOAD_PATH).to receive(:unshift).with("a/dir")
         config.libs = ["a/dir"]
       end
     end
@@ -1079,22 +1033,6 @@ module RSpec::Core
       end
     end
 
-    describe "#requires=" do
-      before { RSpec.should_receive :deprecate }
-
-      it "requires the configured files" do
-        config.should_receive(:require).with('foo').ordered
-        config.should_receive(:require).with('bar').ordered
-        config.requires = ['foo', 'bar']
-      end
-
-      it "stores require paths" do
-        config.should_receive(:require).with("a/path")
-        config.requires = ["a/path"]
-        expect(config.requires).to eq ['a/path']
-      end
-    end
-
     describe "#add_setting" do
       describe "with no modifiers" do
         context "with no additional options" do
@@ -1146,14 +1084,6 @@ module RSpec::Core
         end
       end
 
-      context "with :alias => " do
-        it "is deprecated" do
-          RSpec::should_receive(:deprecate).with(/:alias option/, :replacement => ":alias_with")
-          config.add_setting :custom_option
-          config.add_setting :another_custom_option, :alias => :custom_option
-        end
-      end
-
       context "with :alias_with => " do
         before do
           config.add_setting :custom_option, :alias_with => :another_custom_option
@@ -1254,6 +1184,48 @@ module RSpec::Core
       end
     end
 
+    describe "#alias_example_group_to" do
+      after do
+        RSpec::Core::DSL.example_group_aliases.delete(:my_group_method)
+
+        RSpec.module_eval do
+          class << self
+            undef :my_group_method if method_defined? :my_group_method
+          end
+        end
+
+        RSpec::Core::ExampleGroup.module_eval do
+          class << self
+            undef :my_group_method if method_defined? :my_group_method
+          end
+        end
+      end
+
+      it_behaves_like "metadata hash builder" do
+        def metadata_hash(*args)
+          config.alias_example_group_to :my_group_method, *args
+          group = ExampleGroup.my_group_method("a group")
+          group.metadata
+        end
+      end
+
+      it "allows adding additional metadata" do
+        config.alias_example_group_to :my_group_method, { :some => "thing" }
+        group = ExampleGroup.my_group_method("a group", :another => "thing")
+        expect(group.metadata).to include(:some => "thing", :another => "thing")
+      end
+
+      context 'when the aliased method is used' do
+        it_behaves_like "metadata hash builder" do
+          def metadata_hash(*args)
+            config.alias_example_group_to :my_group_method
+            group = ExampleGroup.my_group_method("a group", *args)
+            group.metadata
+          end
+        end
+      end
+    end
+
     describe "#alias_example_to" do
       it_behaves_like "metadata hash builder" do
         after do
@@ -1368,7 +1340,7 @@ module RSpec::Core
         end
 
         it 'sets up random ordering' do
-          RSpec.stub(:configuration => config)
+          allow(RSpec).to receive_messages(:configuration => config)
           global_ordering = config.ordering_registry.fetch(:global)
           expect(global_ordering).to be_an_instance_of(Ordering::Random)
         end
@@ -1382,7 +1354,7 @@ module RSpec::Core
         end
 
         it 'sets up random ordering' do
-          RSpec.stub(:configuration => config)
+          allow(RSpec).to receive_messages(:configuration => config)
           global_ordering = config.ordering_registry.fetch(:global)
           expect(global_ordering).to be_an_instance_of(Ordering::Random)
         end
@@ -1399,7 +1371,7 @@ module RSpec::Core
         end
 
         it 'clears the random ordering' do
-          RSpec.stub(:configuration => config)
+          allow(RSpec).to receive_messages(:configuration => config)
           list = [1, 2, 3, 4]
           ordering_strategy = config.ordering_registry.fetch(:global)
           expect(ordering_strategy.order(list)).to eq([1, 2, 3, 4])
@@ -1497,5 +1469,11 @@ module RSpec::Core
       end
     end
 
+    # assigns files_or_directories_to_run and triggers post-processing
+    # via `files_to_run`.
+    def assign_files_or_directories_to_run(*value)
+      config.files_or_directories_to_run = value
+      config.files_to_run
+    end
   end
 end