rspec-core 2.99.2 → 3.0.0.beta1

data/spec/rspec/core/formatters/html_formatter_spec.rb

@@ -6,46 +6,32 @@ require 'nokogiri'
 module RSpec
   module Core
     module Formatters
-      describe HtmlFormatter do
+      describe HtmlFormatter, :if => RUBY_VERSION =~ /^(1.8.7|1.9.2|1.9.3|2.0.0)$/ do
+        let(:suffix) {
+          if ::RUBY_PLATFORM == 'java'
+            "-jruby"
+          elsif defined?(Rubinius)
+            "-rbx"
+          else
+            ""
+          end
+        }
 
         let(:root) { File.expand_path("#{File.dirname(__FILE__)}/../../../..") }
         let(:expected_file) do
-          "#{File.dirname(__FILE__)}/html_formatted.html"
+          "#{File.dirname(__FILE__)}/html_formatted-#{::RUBY_VERSION}#{suffix}.html"
         end
 
         let(:generated_html) do
-          options = RSpec::Core::ConfigurationOptions.new(
-            %w[spec/rspec/core/resources/formatter_specs.rb --format html --order defined]
-          )
-          options.parse_options
+          options = %w[spec/rspec/core/resources/formatter_specs.rb --format html --order defined]
 
           err, out = StringIO.new, StringIO.new
           err.set_encoding("utf-8") if err.respond_to?(:set_encoding)
-          out.set_encoding("utf-8") if out.respond_to?(:set_encoding)
-
-          runner = RSpec::Core::Runner.new(options)
-          configuration = runner.instance_variable_get(:@configuration)
-
-          configuration.backtrace_formatter.inclusion_patterns = []
-          configuration.output_stream = out
-          configuration.deprecation_stream = err
-
-          runner.run(err, out)
-
-          html = out.string.gsub(/\d+\.\d+(s| seconds)/, "n.nnnn\\1")
 
-          actual_doc = Nokogiri::HTML(html)
-          actual_doc.css("div.backtrace pre").each do |elem|
-            # This is to minimize churn on backtrace lines that we do not
-            # assert on anyway.
-            backtrace = elem.inner_html.lines.
-              select {|e| e =~ /formatter_specs\.rb/ }.
-              map {|x| x.chomp.split(":")[0..1].join(':') }.
-              join("\n")
-
-            elem.inner_html = backtrace
-          end
-          actual_doc.inner_html
+          command_line = RSpec::Core::CommandLine.new(options)
+          command_line.instance_variable_get("@configuration").backtrace_formatter.inclusion_patterns = []
+          command_line.run(err, out)
+          out.string.gsub(/\d+\.\d+(s| seconds)/, "n.nnnn\\1")
         end
 
         let(:expected_html) do
@@ -56,7 +42,7 @@ module RSpec
         end
 
         before do
-          RSpec.configuration.stub(:load_spec_files) do
+          allow(RSpec.configuration).to receive(:load_spec_files) do
             RSpec.configuration.files_to_run.map {|f| load File.expand_path(f) }
           end
         end
@@ -78,18 +64,7 @@ module RSpec
             select  {|e| e =~ /formatter_specs\.rb/}
         end
 
-        describe 'produced HTML', :if => RUBY_VERSION <= '2.0.0' do
-          # Rubies before 2 are a wild west of different outputs, and it's not
-          # worth the effort to maintain accurate fixtures for all of them.
-          # Since we are verifying fixtures on other rubies, if this code at
-          # least runs we can be reasonably confident the output is right since
-          # behaviour variances that we care about across versions is neglible.
-          it 'is present' do
-            expect(generated_html).to be
-          end
-        end
-
-        describe 'produced HTML', :slow, :if => RUBY_VERSION >= '2.0.0' do
+        describe 'produced HTML' do
           def build_and_verify_formatter_output
             Dir.chdir(root) do
               actual_doc = Nokogiri::HTML(generated_html)
@@ -113,15 +88,15 @@ module RSpec
             end
           end
 
-          it "is identical to the one we designed manually" do
+          it "produces HTML identical to the one we designed manually" do
             build_and_verify_formatter_output
           end
 
           context 'with mathn loaded' do
             include MathnIntegrationSupport
 
-            it "is identical to the one we designed manually", :slow do
-              with_mathn_loaded { build_and_verify_formatter_output }
+            it "produces HTML identical to the one we designed manually" do
+              with_mathn_loaded{ build_and_verify_formatter_output }
             end
           end
         end

data/spec/rspec/core/formatters/json_formatter_spec.rb

@@ -14,7 +14,8 @@ require 'rspec/core/reporter'
 describe RSpec::Core::Formatters::JsonFormatter do
   let(:output) { StringIO.new }
   let(:formatter) { RSpec::Core::Formatters::JsonFormatter.new(output) }
-  let(:reporter) { RSpec::Core::Reporter.new(formatter) }
+  let(:config) { RSpec::Core::Configuration.new }
+  let(:reporter) { RSpec::Core::Reporter.new(config, formatter) }
 
   it "outputs json (brittle high level functional test)" do
     group = RSpec::Core::ExampleGroup.describe("one apiece") do
@@ -97,19 +98,107 @@ describe RSpec::Core::Formatters::JsonFormatter do
 
   describe "#dump_summary" do
     it "adds summary info to the output hash" do
-      duration, example_count, failure_count, pending_count = 1.0, 2, 1, 1
-      formatter.dump_summary(duration, example_count, failure_count, pending_count)
+      values = { :duration => 1.0, :example_count => 2, :failure_count => 1, :pending_count => 1 }
+      formatter.dump_summary(values[:duration], values[:example_count], values[:failure_count], values[:pending_count])
       summary = formatter.output_hash[:summary]
-      %w(duration example_count failure_count pending_count).each do |key|
-        expect(summary[key.to_sym]).to eq eval(key)
+      values.each do |key,value|
+        expect(summary[key]).to eq value
       end
       summary_line = formatter.output_hash[:summary_line]
       expect(summary_line).to eq "2 examples, 1 failure, 1 pending"
     end
+  end
+
+  describe "#dump_profile_slowest_examples" do
+
+    before do
+      group = RSpec::Core::ExampleGroup.describe("group") do
+        # Use a sleep so there is some measurable time, to ensure
+        # the reported percent is 100%, not 0%.
+        example("example") { sleep 0.001 }
+      end
+      group.run(double('reporter').as_null_object)
+
+      formatter.stub(:examples) { group.examples }
+      RSpec.configuration.stub(:profile_examples) { 10 }
+    end
+
+    it "names the example" do
+      formatter.dump_profile_slowest_examples
+      expect(formatter.output_hash[:profile][:examples].first[:full_description]).to eq("group example")
+    end
+
+    it "provides example execution time" do
+      formatter.dump_profile_slowest_examples
+      expect(formatter.output_hash[:profile][:examples].first[:run_time]).not_to be_nil
+    end
+
+    it "has the summary of profile information" do
+      formatter.dump_profile_slowest_examples
+      expect(formatter.output_hash[:profile].keys).to match_array([:examples, :slowest, :total])
+    end
+  end
+
+  describe "#dump_profile_slowest_example_groups" do
+    let(:group) do
+      RSpec::Core::ExampleGroup.describe("slow group") do
+        # Use a sleep so there is some measurable time, to ensure
+        # the reported percent is 100%, not 0%.
+        example("example") { sleep 0.01 }
+      end
+    end
+    let(:rpt) { double('reporter').as_null_object }
+
+    before do
+      RSpec.configuration.stub(:profile_examples) { 10 }
+      group.run(rpt)
+    end
+
+    context "with one example group" do
+      before { formatter.stub(:examples) { group.examples } }
+
+      it "doesn't profile a single example group" do
+        formatter.dump_profile_slowest_example_groups
+        expect(formatter.output_hash[:profile][:groups]).to be_empty
+      end
+    end
+
+    context "with multiple example groups" do
+      before do
+        group2 = RSpec::Core::ExampleGroup.describe("fast group") do
+          example("example 1") { sleep 0.004 }
+          example("example 2") { sleep 0.007 }
+        end
+        group2.run(rpt)
+
+        formatter.stub(:examples) { group.examples + group2.examples }
+      end
+
+      it "provides the slowest example groups" do
+        formatter.dump_profile_slowest_example_groups
+        expect(formatter.output_hash).not_to be_empty
+      end
+
+      it "provides information" do
+        formatter.dump_profile_slowest_example_groups
+        expect(formatter.output_hash[:profile][:groups].first.keys).to match_array([:total_time, :count, :description, :average, :location])
+      end
+
+      it "ranks the example groups by average time" do
+        formatter.dump_profile_slowest_example_groups
+        expect(formatter.output_hash[:profile][:groups].first[:description]).to eq("slow group")
+      end
+    end
+
+    it "depends on parent_groups to get the top level example group" do
+      ex = ""
+      group.describe("group 2") do
+        describe "group 3" do
+          ex = example("nested example 1")
+        end
+      end
 
-    it "ignores --profile" do
-      allow(RSpec.configuration).to receive(:profile_examples).and_return(true)
-      formatter.dump_summary(1.0, 2, 1, 1)
+      expect(ex.example_group.parent_groups.last).to eq(group)
     end
   end
 end

data/spec/rspec/core/hooks_filtering_spec.rb

@@ -35,7 +35,7 @@ module RSpec::Core
             c.before(:match => true) { filters << "before each in config"}
             c.after(:match => true)  { filters << "after each in config"}
           end
-          group = ExampleGroup.describe("group", :match => true)
+          group = ExampleGroup.describe(:match => true)
           group.example("example") {}
           group.run
           expect(filters).to eq([
@@ -55,7 +55,7 @@ module RSpec::Core
           c.after(:each,  :match => true) { filters << "after each in config"}
           c.after(:all,   :match => true) { filters << "after all in config"}
         end
-        group = ExampleGroup.describe("group", :match => true)
+        group = ExampleGroup.describe(:match => true)
         group.example("example") {}
         group.run
         expect(filters).to eq([
@@ -125,7 +125,7 @@ module RSpec::Core
           c.after(:each,  :match => false) { filters << "after each in config"}
           c.after(:all,   :match => false) { filters << "after all in config"}
         end
-        group = ExampleGroup.describe("group", :match => true)
+        group = ExampleGroup.describe(:match => true)
         group.example("example") {}
         group.run
         expect(filters).to eq([])
@@ -196,7 +196,7 @@ module RSpec::Core
           c.after(:each,  :one => 1, :two => 2, :three => 3) { filters << "after each in config"}
           c.after(:all,   :one => 1, :three => 3)            { filters << "after all in config"}
         end
-        group = ExampleGroup.describe("group", :one => 1, :two => 2, :three => 3)
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
         group.example("example") {}
         group.run
         expect(filters).to eq([
@@ -217,7 +217,7 @@ module RSpec::Core
           c.after(:each,  :one => 1, :two => 2, :three => 3, :four => 4) { filters << "after each in config"}
           c.after(:all,   :one => 1, :three => 3, :four => 4)            { filters << "after all in config"}
         end
-        group = ExampleGroup.describe("group", :one => 1, :two => 2, :three => 3)
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
         group.example("example") {}
         group.run
         expect(filters).to eq([])

data/spec/rspec/core/hooks_spec.rb

@@ -4,6 +4,10 @@ module RSpec::Core
   describe Hooks do
     class HooksHost
       include Hooks
+
+      def parent_groups
+        []
+      end
     end
 
     [:before, :after, :around].each do |type|
@@ -22,61 +26,51 @@ module RSpec::Core
         end
       end
 
-      [true, false].each do |config_value|
-        context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
-          before(:each) do
-            Kernel.stub(:warn)
-            allow_deprecation unless config_value
-            RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
-          end
-
-          describe "##{type}(no scope)" do
-            let(:instance) { HooksHost.new }
+      describe "##{type}(no scope)" do
+        let(:instance) { HooksHost.new }
 
-            it "defaults to :each scope if no arguments are given" do
-              hooks = instance.send(type) {}
-              hook = hooks.first
-              expect(instance.hooks[type][:each]).to include(hook)
-            end
+        it "defaults to :each scope if no arguments are given" do
+          hooks = instance.send(type) {}
+          hook = hooks.first
+          expect(instance.hooks[type][:each]).to include(hook)
+        end
 
-            it "defaults to :each scope if the only argument is a metadata hash" do
-              hooks = instance.send(type, :foo => :bar) {}
-              hook = hooks.first
-              expect(instance.hooks[type][:each]).to include(hook)
-            end
+        it "defaults to :each scope if the only argument is a metadata hash" do
+          hooks = instance.send(type, :foo => :bar) {}
+          hook = hooks.first
+          expect(instance.hooks[type][:each]).to include(hook)
+        end
 
-            it "raises an error if only metadata symbols are given as arguments" do
-              expect { instance.send(type, :foo, :bar) {} }.to raise_error(ArgumentError)
-            end
-          end
+        it "raises an error if only metadata symbols are given as arguments" do
+          expect { instance.send(type, :foo, :bar) {} }.to raise_error(ArgumentError)
         end
       end
     end
 
     [:before, :after].each do |type|
       [:each, :all, :suite].each do |scope|
-        [true, false].each do |config_value|
-          context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
-            before(:each) do
-              allow_deprecation unless config_value
-              RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
-            end
+        describe "##{type}(#{scope.inspect})" do
+          let(:instance) { HooksHost.new }
+          let!(:hook) do
+            hooks = instance.send(type, scope) {}
+            hooks.first
+          end
 
-            describe "##{type}(#{scope.inspect})" do
-              let(:instance) { HooksHost.new }
-              let!(:hook) do
-                hooks = instance.send(type, scope) {}
-                hooks.first
-              end
+          it "does not make #{scope.inspect} a metadata key" do
+            expect(hook.options).to be_empty
+          end
 
-              it "does not make #{scope.inspect} a metadata key" do
-                expect(hook.options).to be_empty
-              end
+          it "is scoped to #{scope.inspect}" do
+            expect(instance.hooks[type][scope]).to include(hook)
+          end
 
-              it "is scoped to #{scope.inspect}" do
-                expect(instance.hooks[type][scope]).to include(hook)
-              end
-            end
+          it 'does not run when in dry run mode' do
+            RSpec.configuration.dry_run = true
+
+            expect { |b|
+              instance.send(type, scope, &b)
+              instance.run_hook(type, scope)
+            }.not_to yield_control
           end
         end
       end
@@ -87,14 +81,14 @@ module RSpec::Core
         it "does not run the example" do
           examples = []
           group = ExampleGroup.describe do
-            around do |example|
+            around do
             end
             it "foo" do
               examples << self
             end
           end
           group.run
-          expect(examples).to have(0).example
+          expect(examples).to eq([])
         end
       end
 
@@ -110,7 +104,26 @@ module RSpec::Core
             end
           end
           group.run
-          expect(examples).to have(1).example
+          expect(examples.count).to eq(1)
+        end
+
+        it "exposes example metadata to each around hook" do
+          foos = {}
+          group = ExampleGroup.describe do
+            around do |ex|
+              foos[:first] = ex.metadata[:foo]
+              ex.run
+            end
+            around do |ex|
+              foos[:second] = ex.metadata[:foo]
+              ex.run
+            end
+            it "does something", :foo => :bar do
+            end
+          end
+
+          group.run
+          expect(foos).to eq({:first => :bar, :second => :bar})
         end
       end
 
@@ -125,12 +138,13 @@ module RSpec::Core
             around do |example|
               yielder { example.run }
             end
+
             it "foo" do
               examples << self
             end
           end
           group.run
-          expect(examples).to have(1).example
+          expect(examples.count).to eq(1)
         end
       end
     end

data/spec/rspec/core/memoized_helpers_spec.rb

@@ -37,44 +37,6 @@ module RSpec::Core
         end
       end
 
-      describe "with a symbol" do
-        it "returns the string form and issues a deprecation warning" do
-          the_subject = :unset
-          deprecations = []
-          allow(RSpec).to receive(:warn_deprecation) { |msg| deprecations << msg }
-
-          line = __LINE__ + 1
-          ExampleGroup.describe :symbol do
-            example { the_subject = subject }
-          end.run
-
-          expect(the_subject).to eq("symbol")
-          expect(deprecations.size).to eq(1)
-          deprecation = deprecations.first
-          expect(deprecation).to match(/describe <a Symbol>/)
-          expect(deprecation).to include("#{__FILE__}:#{line}")
-        end
-      end
-
-      describe "with a hash" do
-        it "returns a blank string and issues a deprecation warning" do
-          the_subject = :unset
-          deprecations = []
-          allow(RSpec).to receive(:warn_deprecation) { |msg| deprecations << msg }
-
-          line = __LINE__ + 1
-          ExampleGroup.describe :foo => 3 do
-            example { the_subject = subject }
-          end.run
-
-          expect(the_subject).to eq("")
-          expect(deprecations.size).to eq(1)
-          deprecation = deprecations.first
-          expect(deprecation).to match(/describe <a Hash>/)
-          expect(deprecation).to include("#{__FILE__}:#{line}")
-        end
-      end
-
       it "can be overriden and super'd to from a nested group" do
         outer_subject_value = inner_subject_value = nil
 
@@ -106,18 +68,6 @@ module RSpec::Core
         expect(example_yielded_to_subject).to eq example_yielded_to_example
       end
 
-      context "doesn't issue a deprecation when used with doubles" do
-        subject do
-          Struct.new(:value) do
-            def working_with?(double)
-              double.value >= value
-            end
-          end.new 1
-        end
-
-        it { should be_working_with double(:value => 10) }
-      end
-
       [false, nil].each do |falsy_value|
         context "with a value of #{falsy_value.inspect}" do
           it "is evaluated once per example" do
@@ -183,64 +133,19 @@ module RSpec::Core
           expect(subject_value).to eq([4, 5, 6, :override])
         end
 
-        context 'when referenced in a `before(:all)` hook' do
-          before do
-            expect(::RSpec).to respond_to(:warn_deprecation)
-            ::RSpec.stub(:warn_deprecation)
-          end
-
-          def define_and_run_group
-            values = { :reference_lines => [] }
+        [:before, :after].each do |hook|
+          it "raises an error when referenced from `#{hook}(:all)`" do
+            result = nil
+            line   = nil
 
             ExampleGroup.describe do
-              subject { [1, 2] }
-              let(:list) { %w[ a b ] }
-
-              before(:all) do
-                subject << 3; values[:reference_lines] << __LINE__
-                values[:final_subject_value_in_before_all] = subject; values[:reference_lines] << __LINE__
-              end
-
-              example do
-                list << '1'
-                values[:list_in_ex_1] = list
-                values[:subject_value_in_example] = subject
-              end
-
-              example do
-                list << '2'
-                values[:list_in_ex_2] = list
-              end
+              subject { nil }
+              send(hook, :all) { result = (subject rescue $!) }; line = __LINE__
+              example { }
             end.run
 
-            values
-          end
-
-          it 'memoizes the value within the before(:all) hook' do
-            values = define_and_run_group
-            expect(values.fetch(:final_subject_value_in_before_all)).to eq([1, 2, 3])
-          end
-
-          it 'preserves the memoization into the individual examples' do
-            values = define_and_run_group
-            expect(values.fetch(:subject_value_in_example)).to eq([1, 2, 3])
-          end
-
-          it 'does not cause other lets to be shared across examples' do
-            values = define_and_run_group
-            expect(values.fetch(:list_in_ex_1)).to eq(%w[ a b 1 ])
-            expect(values.fetch(:list_in_ex_2)).to eq(%w[ a b 2 ])
-          end
-
-          it 'prints a warning since `subject` declarations are not intended to be used in :all hooks' do
-            msgs = []
-            ::RSpec.stub(:warn_deprecation) { |msg| msgs << msg }
-
-            values = define_and_run_group
-
-            expect(msgs).to include(*values[:reference_lines].map { |line|
-              match(/subject accessed.*#{__FILE__}:#{line}/m)
-            })
+            expect(result).to be_an(Exception)
+            expect(result.message).to match(/subject accessed.*#{hook}\(:all\).*#{__FILE__}:#{line}/m)
           end
         end
       end
@@ -393,169 +298,7 @@ module RSpec::Core
           it { should_not be_not_ok }
         end
 
-        expect(group.run).to be true
-      end
-
-      it 'supports a new expect-based syntax' do
-        group = ExampleGroup.describe([1, 2, 3]) do
-          it { is_expected.to be_an Array }
-          it { is_expected.not_to include 4 }
-        end
-
-        expect(group.run).to be true
-      end
-    end
-
-    describe "#its" do
-      extend SilenceDSLDeprecations
-      silence_dsl_deprecations do
-        it "should issue deprecation warning" do
-          expect_deprecation_with_call_site(__FILE__, __LINE__+1, '`its` method')
-          RSpec::Core::ExampleGroup.its(nil) {}
-        end
-
-        subject do
-          Class.new do
-            def initialize
-              @call_count = 0
-            end
-
-            def call_count
-              @call_count += 1
-            end
-          end.new
-        end
-
-        context "with a call counter" do
-          its(:call_count) { should eq(1) }
-        end
-
-        context "with nil value" do
-          subject do
-            Class.new do
-              def nil_value
-                nil
-              end
-            end.new
-          end
-          its(:nil_value) { should be_nil }
-        end
-
-        context "with nested attributes" do
-          subject do
-            Class.new do
-              def name
-                "John"
-              end
-            end.new
-          end
-          its("name")            { should eq("John") }
-          its("name.size")       { should eq(4) }
-          its("name.size.class") { should eq(Fixnum) }
-        end
-
-        context "when it responds to #[]" do
-          subject do
-            Class.new do
-              def [](*objects)
-                objects.map do |object|
-                  "#{object.class}: #{object.to_s}"
-                end.join("; ")
-              end
-
-              def name
-                "George"
-              end
-            end.new
-          end
-          its([:a]) { should eq("Symbol: a") }
-          its(['a']) { should eq("String: a") }
-          its([:b, 'c', 4]) { should eq("Symbol: b; String: c; Fixnum: 4") }
-          its(:name) { should eq("George") }
-          context "when referring to an attribute without the proper array syntax" do
-            context "it raises an error" do
-              its(:age) do
-                expect do
-                  should eq(64)
-                end.to raise_error(NoMethodError)
-              end
-            end
-          end
-        end
-
-        context "when it does not respond to #[]" do
-          subject { Object.new }
-
-          context "it raises an error" do
-            its([:a]) do
-              expect do
-                should eq("Symbol: a")
-              end.to raise_error(NoMethodError)
-            end
-          end
-        end
-
-        context "calling and overriding super" do
-          it "calls to the subject defined in the parent group" do
-            group = ExampleGroup.describe(Array) do
-              subject { [1, 'a'] }
-
-              its(:last) { should eq("a") }
-
-              describe '.first' do
-                def subject; super().first; end
-
-                its(:next) { should eq(2) }
-              end
-            end
-
-            expect(group.run).to be_truthy
-          end
-        end
-
-        context "with nil subject" do
-          subject do
-            Class.new do
-              def initialize
-                @counter = -1
-              end
-              def nil_if_first_time
-                @counter += 1
-                @counter == 0 ? nil : true
-              end
-            end.new
-          end
-          its(:nil_if_first_time) { should be(nil) }
-        end
-
-        context "with false subject" do
-          subject do
-            Class.new do
-              def initialize
-                @counter = -1
-              end
-              def false_if_first_time
-                @counter += 1
-                @counter > 0
-              end
-            end.new
-          end
-          its(:false_if_first_time) { should be(false) }
-        end
-
-        describe 'accessing `subject` in `before` and `let`' do
-          subject { 'my subject' }
-          before { @subject_in_before = subject }
-          let(:subject_in_let) { subject }
-          let!(:eager_loaded_subject_in_let) { subject }
-
-          # These examples read weird, because we're actually
-          # specifying the behaviour of `its` itself
-          its(nil) { expect(subject).to eq('my subject') }
-          its(nil) { expect(@subject_in_before).to eq('my subject') }
-          its(nil) { expect(subject_in_let).to eq('my subject') }
-          its(nil) { expect(eager_loaded_subject_in_let).to eq('my subject') }
-        end
+        expect(group.run).to be_truthy
       end
     end
 
@@ -656,64 +399,19 @@ module RSpec::Core
       end
     end
 
-    context 'when referenced in a `before(:all)` hook' do
-      before do
-        expect(::RSpec).to respond_to(:warn_deprecation)
-        ::RSpec.stub(:warn_deprecation)
-      end
-
-      def define_and_run_group
-        values = { :reference_lines => [] }
+    [:before, :after].each do |hook|
+      it "raises an error when referenced from `#{hook}(:all)`" do
+        result = nil
+        line   = nil
 
         ExampleGroup.describe do
-          let(:list) { [1, 2] }
-          subject { %w[ a b ] }
-
-          before(:all) do
-            list << 3; values[:reference_lines] << __LINE__
-            values[:final_list_value_in_before_all] = list; values[:reference_lines] << __LINE__
-          end
-
-          example do
-            subject << "1"
-            values[:subject_in_ex_1] = subject
-            values[:list_value_in_example] = list
-          end
-
-          example do
-            subject << "2"
-            values[:subject_in_ex_2] = subject
-          end
+          let(:foo) { nil }
+          send(hook, :all) { result = (foo rescue $!) }; line = __LINE__
+          example { }
         end.run
 
-        values
-      end
-
-      it 'memoizes the value within the before(:all) hook' do
-        values = define_and_run_group
-        expect(values.fetch(:final_list_value_in_before_all)).to eq([1, 2, 3])
-      end
-
-      it 'preserves the memoized value into the examples' do
-        values = define_and_run_group
-        expect(values.fetch(:list_value_in_example)).to eq([1, 2, 3])
-      end
-
-      it 'does not cause the subject to be shared across examples' do
-        values = define_and_run_group
-        expect(values.fetch(:subject_in_ex_1)).to eq(%w[ a b 1 ])
-        expect(values.fetch(:subject_in_ex_2)).to eq(%w[ a b 2 ])
-      end
-
-      it 'prints a warning since `let` declarations are not intended to be used in :all hooks' do
-        msgs = []
-        ::RSpec.stub(:warn_deprecation) { |msg| msgs << msg }
-
-        values = define_and_run_group
-
-        expect(msgs).to include(*values[:reference_lines].map { |line|
-          match(/let declaration `list` accessed.*#{__FILE__}:#{line}/m)
-        })
+        expect(result).to be_an(Exception)
+        expect(result.message).to match(/let declaration `foo` accessed.*#{hook}\(:all\).*#{__FILE__}:#{line}/m)
       end
     end
 
@@ -758,7 +456,7 @@ module RSpec::Core
         expect(subject_id_in_let).to eq(@subject_id_in_before)
       end
 
-      it { is_expected.to eq(subject) }
+      it { should eq(subject) }
     end
 
     describe Object do