opal-connect-rspec 0.5.0

data/rspec-core/spec/rspec/core/formatters/snippet_extractor_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'rspec/core/formatters/snippet_extractor'
+
+module RSpec
+  module Core
+    module Formatters
+      RSpec.describe SnippetExtractor do
+        it "falls back on a default message when it doesn't understand a line" do
+          expect(RSpec::Core::Formatters::SnippetExtractor.new.snippet_for("blech")).to eq(["# Couldn't get snippet for blech", 1])
+        end
+
+        it "falls back on a default message when it doesn't find the file" do
+         expect(RSpec::Core::Formatters::SnippetExtractor.new.lines_around("blech", 8)).to eq("# Couldn't get snippet for blech")
+        end
+
+        it "falls back on a default message when it gets a security error" do
+          message = nil
+          safely do
+            message = RSpec::Core::Formatters::SnippetExtractor.new.lines_around("blech", 8)
+          end
+          expect(message).to eq("# Couldn't get snippet for blech")
+        end
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/formatters_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'pathname'
+
+module RSpec::Core::Formatters
+  describe Loader do
+
+    let(:output)   { StringIO.new }
+    let(:reporter) { instance_double "Reporter", :register_listener => nil }
+    let(:loader)   { Loader.new reporter }
+
+    describe "#add(formatter)" do
+      let(:path) { File.join(Dir.tmpdir, 'output.txt') }
+
+      it "adds to the list of formatters" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ Symbol)" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ String)" do
+        loader.add 'documentation', output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by class" do
+        formatter_class = Class.new(BaseTextFormatter)
+        Loader.formatters[formatter_class] = []
+        loader.add formatter_class, output
+        expect(loader.formatters.first).to be_an_instance_of(formatter_class)
+      end
+
+      it "finds a formatter by class name" do
+        stub_const("CustomFormatter", Class.new(BaseFormatter))
+        Loader.formatters[CustomFormatter] = []
+        loader.add "CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(CustomFormatter)
+      end
+
+      context "when a legacy formatter is added with RSpec::LegacyFormatters" do
+        formatter_class = Struct.new(:output)
+        let(:formatter) { double "formatter", :notifications => notifications }
+        let(:notifications) { [:a, :b, :c] }
+
+        before do
+          class_double("RSpec::LegacyFormatters", :load_formatter => formatter).as_stubbed_const
+        end
+
+        it "loads formatters from the external gem" do
+          loader.add formatter_class, output
+          expect(loader.formatters).to eq [formatter]
+        end
+
+        it "subscribes the formatter to the notifications the adaptor implements" do
+          expect(reporter).to receive(:register_listener).with(formatter, *notifications)
+          loader.add formatter_class, output
+        end
+      end
+
+      context "when a legacy formatter is added without RSpec::LegacyFormatters" do
+        formatter_class = Struct.new(:output)
+
+        before do
+          allow_deprecation
+        end
+
+        it "issues a deprecation" do
+          expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 2,
+            /The #{formatter_class} formatter uses the deprecated formatter interface/)
+          loader.add formatter_class, output
+        end
+      end
+
+      it "finds a formatter by class fully qualified name" do
+        stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+        Loader.formatters[RSpec::CustomFormatter] = []
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "requires a formatter file based on its fully qualified name" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter') do
+          stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+          Loader.formatters[RSpec::CustomFormatter] = []
+        end
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "raises NameError if class is unresolvable" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter3')
+        expect { loader.add "RSpec::CustomFormatter3", output }.to raise_error(NameError)
+      end
+
+      it "raises ArgumentError if formatter is unknown" do
+        expect { loader.add :progresss, output }.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
+          loader.add('doc', path)
+          expect(loader.formatters.first.output).to be_a(File)
+          expect(loader.formatters.first.output.path).to eq(path)
+        end
+
+        it "accepts Pathname objects for file paths" do
+          pathname = Pathname.new(path)
+          loader.add('doc', pathname)
+          expect(loader.formatters.first.output).to be_a(File)
+          expect(loader.formatters.first.output.path).to eq(path)
+        end
+      end
+
+      context "when a duplicate formatter exists" do
+        before { loader.add :documentation, output }
+
+        it "doesn't add the formatter for the same output target" do
+          expect {
+            loader.add :documentation, output
+          }.not_to change { loader.formatters.length }
+        end
+
+        it "adds the formatter for different output targets" do
+          expect {
+            loader.add :documentation, path
+          }.to change { loader.formatters.length }
+        end
+      end
+    end
+
+    describe "#setup_default", "with profiling enabled" do
+      let(:setup_default) { loader.setup_default output, output }
+
+      before do
+        allow(RSpec.configuration).to receive(:profile_examples?) { true }
+      end
+
+      context "without an existing profile formatter" do
+        it "will add the profile formatter" do
+          allow(reporter).to receive(:registered_listeners).with(:dump_profile) { [] }
+          setup_default
+          expect(loader.formatters.last).to be_a ::RSpec::Core::Formatters::ProfileFormatter
+        end
+      end
+
+      context "when a formatter that implement #dump_profile is added" do
+        it "wont add the profile formatter" do
+          allow(reporter).to receive(:registered_listeners).with(:dump_profile) { [:json] }
+          setup_default
+          expect(
+            loader.formatters.map(&:class)
+          ).to_not include ::RSpec::Core::Formatters::ProfileFormatter
+        end
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/hooks_filtering_spec.rb

@@ -0,0 +1,227 @@
+require "spec_helper"
+
+module RSpec::Core
+  RSpec.describe "config block hook filtering" do
+    describe "unfiltered hooks" do
+      it "is run" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all) { filters << "before all in config"}
+          c.around(:each) {|example| filters << "around each in config"; example.run}
+          c.before(:each) { filters << "before each in config"}
+          c.after(:each) { filters << "after each in config"}
+          c.after(:all) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+    end
+
+    describe "hooks with single filters" do
+
+      context "with no scope specified" do
+        it "is run around|before|after :each if the filter matches the example group's filter" do
+          filters = []
+          RSpec.configure do |c|
+            c.around(:match => true) {|example| filters << "around each in config"; example.run}
+            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.example("example") {}
+          group.run
+          expect(filters).to eq([
+            "around each in config",
+            "before each in config",
+            "after each in config"
+          ])
+        end
+      end
+
+      it "is run if the filter matches the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => true) { filters << "before all in config"}
+          c.around(:each, :match => true) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => true) { filters << "before each in config"}
+          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.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "runs before|after :all hooks on matching nested example groups" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = nil
+
+        group = ExampleGroup.describe "group" do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+          end
+        end
+        group.run
+
+        expect(example_1_filters).to be_empty
+        expect(example_2_filters).to eq([:before_all])
+        expect(filters).to eq([:before_all, :after_all])
+      end
+
+      it "runs before|after :all hooks only on the highest level group that matches the filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = example_3_filters = nil
+
+        group = ExampleGroup.describe "group", :match => true do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+            describe "sub-subgroup", :match => true do
+              it("example 3") { example_3_filters = filters.dup }
+            end
+          end
+        end
+        group.run
+
+        expect(example_1_filters).to eq([:before_all])
+        expect(example_2_filters).to eq([:before_all])
+        expect(example_3_filters).to eq([:before_all])
+
+        expect(filters).to eq([:before_all, :after_all])
+      end
+
+      it "does not run if the filter doesn't match the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => false) { filters << "before all in config"}
+          c.around(:each, :match => false) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => false) { filters << "before each in config"}
+          c.after(:each,  :match => false) { filters << "after each in config"}
+          c.after(:all,   :match => false) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:match => true)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([])
+      end
+
+      context "when the hook filters apply to individual examples instead of example groups" do
+        let(:each_filters) { [] }
+        let(:all_filters) { [] }
+
+        let(:group) do
+          md = example_metadata
+          ExampleGroup.describe do
+            it("example", md) { }
+          end
+        end
+
+        def filters
+          each_filters + all_filters
+        end
+
+        before(:each) do
+          af, ef = all_filters, each_filters
+
+          RSpec.configure do |c|
+            c.before(:all,  :foo => :bar) { af << "before all in config"}
+            c.around(:each, :foo => :bar) {|example| ef << "around each in config"; example.run}
+            c.before(:each, :foo => :bar) { ef << "before each in config"}
+            c.after(:each,  :foo => :bar) { ef << "after each in config"}
+            c.after(:all,   :foo => :bar) { af << "after all in config"}
+          end
+
+          group.run
+        end
+
+        describe 'an example with matching metadata' do
+          let(:example_metadata) { { :foo => :bar } }
+
+          it "runs the `:each` hooks" do
+            expect(each_filters).to eq([
+              'around each in config',
+              'before each in config',
+              'after each in config'
+            ])
+          end
+
+          it "does not run the `:all` hooks" do
+            expect(all_filters).to be_empty
+          end
+        end
+
+        describe 'an example without matching metadata' do
+          let(:example_metadata) { { :foo => :bazz } }
+
+          it "does not run any of the hooks" do
+            expect(filters).to be_empty
+          end
+        end
+      end
+    end
+
+    describe "hooks with multiple filters" do
+      it "is run if all hook filters match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :one => 1)              {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2)              { filters << "before each in config"}
+          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.example("example") {}
+        group.run
+        expect(filters).to eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "does not run if some hook filters don't match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1, :four => 4)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :four => 4)                         {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2, :four => 4)              { filters << "before each in config"}
+          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(:one => 1, :two => 2, :three => 3)
+        group.example("example") {}
+        group.run
+        expect(filters).to eq([])
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/hooks_spec.rb

@@ -0,0 +1,447 @@
+require "spec_helper"
+
+module RSpec::Core
+  RSpec.describe Hooks do
+    class HooksHost
+      include Hooks
+
+      def parent_groups
+        []
+      end
+    end
+
+    [:before, :after, :around].each do |type|
+      [:example, :context].each do |scope|
+        next if type == :around && scope == :context
+
+        describe "##{type}(#{scope})" do
+          it_behaves_like "metadata hash builder" do
+            define_method :metadata_hash do |*args|
+              instance = HooksHost.new
+              args.unshift scope if scope
+              hooks = instance.send(type, *args) {}
+              hooks.first.options
+            end
+          end
+        end
+      end
+
+      describe "##{type}(no scope)" do
+        let(:instance) { HooksHost.new }
+
+        it "defaults to :example scope if no arguments are given" do
+          hooks = instance.send(type) {}
+          hook = hooks.first
+          expect(instance.hooks[type][:example]).to include(hook)
+        end
+
+        it "defaults to :example scope if the only argument is a metadata hash" do
+          hooks = instance.send(type, :foo => :bar) {}
+          hook = hooks.first
+          expect(instance.hooks[type][:example]).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
+    end
+
+    [:before, :after].each do |type|
+      [:example, :context, :suite].each do |scope|
+        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 "is scoped to #{scope.inspect}" do
+            expect(instance.hooks[type][scope]).to include(hook)
+          end
+
+          it 'does not run when in dry run mode' do
+            RSpec.configuration.dry_run = true
+
+            expect { |b|
+              instance.send(type, scope, &b)
+              instance.hooks.run(type, scope, double("Example").as_null_object)
+            }.not_to yield_control
+          end
+        end
+      end
+    end
+
+    context "when an error happens in `after(:suite)`" do
+      it 'allows the error to propagate to the user' do
+        RSpec.configuration.after(:suite) { 1 / 0 }
+
+        expect {
+          RSpec.configuration.hooks.run(:after, :suite, SuiteHookContext.new)
+        }.to raise_error(ZeroDivisionError)
+      end
+    end
+
+    context "when an error happens in `before(:suite)`" do
+      it 'allows the error to propagate to the user' do
+        RSpec.configuration.before(:suite) { 1 / 0 }
+
+        expect {
+          RSpec.configuration.hooks.run(:before, :suite, SuiteHookContext.new)
+        }.to raise_error(ZeroDivisionError)
+      end
+    end
+
+    describe "#around" do
+      context "when it does not run the example" do
+        context "for a hook declared in the group" do
+          it 'converts the example to a skipped example so the user is made aware of it' do
+            ex = nil
+            group = RSpec.describe do
+              around { }
+              ex = example("not run") { }
+            end
+
+            group.run
+            expect(ex.execution_result.status).to eq(:pending)
+          end
+        end
+
+        context "for a hook declared in config" do
+          it 'converts the example to a skipped example so the user is made aware of it' do
+            RSpec.configuration.around { }
+
+            ex = nil
+            group = RSpec.describe do
+              ex = example("not run") { }
+            end
+
+            group.run
+            expect(ex.execution_result.status).to eq(:pending)
+          end
+        end
+
+        if RUBY_VERSION.to_f < 1.9
+          def hook_desc(_)
+            "around hook"
+          end
+        else
+          def hook_desc(line)
+            "around hook at #{Metadata.relative_path(__FILE__)}:#{line}"
+          end
+        end
+
+        it 'indicates which around hook did not run the example in the pending message' do
+          ex = nil
+          line = __LINE__ + 3
+          group = RSpec.describe do
+            around { |e| e.run }
+            around { }
+            around { |e| e.run }
+
+            ex = example("not run") { }
+          end
+
+          group.run
+          expect(ex.execution_result.pending_message).to eq("#{hook_desc(line)} did not execute the example")
+        end
+      end
+
+      it 'considers the hook to have run when passed as a block to a method that yields' do
+        ex = nil
+        group = RSpec.describe do
+          def transactionally
+            yield
+          end
+
+          around { |e| transactionally(&e) }
+          ex = example("run") { }
+        end
+
+        group.run
+        expect(ex.execution_result.status).to eq(:passed)
+      end
+
+      it 'does not consider the hook to have run when passed as a block to a method that does not yield' do
+        ex = nil
+        group = RSpec.describe do
+          def transactionally; end
+
+          around { |e| transactionally(&e) }
+          ex = example("not run") { }
+        end
+
+        group.run
+        expect(ex.execution_result.status).to eq(:pending)
+      end
+
+      context "when not running the example within the around block" do
+        it "does not run the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          expect(examples).to eq([])
+        end
+      end
+
+      context "when running the example within the around block" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do |example|
+              example.run
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          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
+
+        it "exposes the full example interface to each around hook" do
+          data_1 = {}
+          data_2 = {}
+          ex     = nil
+
+          group = ExampleGroup.describe do
+            def self.data_from(ex)
+              {
+                :description => ex.description,
+                :full_description => ex.full_description,
+                :example_group => ex.example_group,
+                :file_path => ex.file_path,
+                :location => ex.location
+              }
+            end
+
+            around do |example|
+              data_1.update(self.class.data_from example)
+              example.run
+            end
+
+            around do |example|
+              data_2.update(self.class.data_from example)
+              example.run
+            end
+
+            ex = example("the example") { }
+          end
+
+          group.run
+
+          expected_data = group.data_from(ex)
+          expect(data_1).to eq(expected_data)
+          expect(data_2).to eq(expected_data)
+        end
+
+        it "exposes a sensible inspect value" do
+          inspect_value = nil
+          group = ExampleGroup.describe do
+            around do |ex|
+              inspect_value = ex.inspect
+            end
+
+            it "does something" do
+            end
+          end
+
+          group.run
+          expect(inspect_value).to match(/ExampleProcsy/)
+        end
+      end
+
+      context "when running the example within a block passed to a method" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            def yielder
+              yield
+            end
+
+            around do |example|
+              yielder { example.run }
+            end
+
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          expect(examples.count).to eq(1)
+        end
+      end
+    end
+
+    [:all, :each].each do |scope|
+      describe "prepend_before(#{scope})" do
+        it "adds to the front of the list of before(:#{scope}) hooks" do
+          messages = []
+
+          RSpec.configure { |config| config.before(scope)         { messages << "config 3" } }
+          RSpec.configure { |config| config.prepend_before(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.before(scope)         { messages << "config 4" } }
+          RSpec.configure { |config| config.prepend_before(scope) { messages << "config 1" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.before(scope)         { messages << "group 3" }
+          group.prepend_before(scope) { messages << "group 2" }
+          group.before(scope)         { messages << "group 4" }
+          group.prepend_before(scope) { messages << "group 1" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'config 1',
+            'config 2',
+            'config 3',
+            'config 4',
+            'group 3',
+            'group 4'
+          ])
+        end
+      end
+
+      describe "append_before(#{scope})" do
+        it "adds to the back of the list of before(:#{scope}) hooks (same as `before`)" do
+          messages = []
+
+          RSpec.configure { |config| config.before(scope)        { messages << "config 1" } }
+          RSpec.configure { |config| config.append_before(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.before(scope)        { messages << "config 3" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.before(scope)        { messages << "group 1" }
+          group.append_before(scope) { messages << "group 2" }
+          group.before(scope)        { messages << "group 3" }
+
+          group.run
+
+          expect(messages).to eq([
+            'config 1',
+            'config 2',
+            'config 3',
+            'group 1',
+            'group 2',
+            'group 3'
+          ])
+        end
+      end
+
+      describe "prepend_after(#{scope})" do
+        it "adds to the front of the list of after(:#{scope}) hooks (same as `after`)" do
+          messages = []
+
+          RSpec.configure { |config| config.after(scope)         { messages << "config 3" } }
+          RSpec.configure { |config| config.prepend_after(scope) { messages << "config 2" } }
+          RSpec.configure { |config| config.after(scope)         { messages << "config 1" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.after(scope)         { messages << "group 3" }
+          group.prepend_after(scope) { messages << "group 2" }
+          group.after(scope)         { messages << "group 1" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'group 3',
+            'config 1',
+            'config 2',
+            'config 3'
+          ])
+        end
+      end
+
+      describe "append_after(#{scope})" do
+        it "adds to the back of the list of after(:#{scope}) hooks" do
+          messages = []
+
+          RSpec.configure { |config| config.after(scope)        { messages << "config 2" } }
+          RSpec.configure { |config| config.append_after(scope) { messages << "config 3" } }
+          RSpec.configure { |config| config.after(scope)        { messages << "config 1" } }
+          RSpec.configure { |config| config.append_after(scope) { messages << "config 4" } }
+
+          group = ExampleGroup.describe { example {} }
+          group.after(scope)        { messages << "group 2" }
+          group.append_after(scope) { messages << "group 3" }
+          group.after(scope)        { messages << "group 1" }
+          group.append_after(scope) { messages << "group 4" }
+
+          group.run
+
+          expect(messages).to eq([
+            'group 1',
+            'group 2',
+            'config 1',
+            'config 2',
+            'config 3',
+            'config 4',
+            'group 3',
+            'group 4'
+          ])
+        end
+      end
+    end
+
+    describe "lambda" do
+      it "can be used as a hook" do
+        messages = []
+        count = 0
+        hook = lambda {|e| messages << "hook #{count = count + 1}"; e.run }
+
+        RSpec.configure do |c|
+          c.around(:each, &hook)
+          c.around(:each, &hook)
+        end
+
+        group = ExampleGroup.describe { example { messages << "example" } }
+        group.run
+        expect(messages).to eq ["hook 1", "hook 2", "example"]
+      end
+    end
+
+    it "only defines methods that are intended to be part of RSpec's public API (+ `hooks`)" do
+      expect(Hooks.private_instance_methods).to eq([])
+
+      expect(Hooks.instance_methods.map(&:to_sym)).to match_array([
+        :before, :after, :around,
+        :append_before, :append_after,
+        :prepend_before, :prepend_after,
+        :hooks
+      ])
+    end
+  end
+end