rspec-core 2.11.1 → 3.11.0

data/spec/rspec/core/hooks_filtering_spec.rb

@@ -1,227 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe "config block hook filtering" do
-    describe "unfiltered hooks" do
-      it "should be ran" 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
-        filters.should 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 "should be ran 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(:match => true)
-          group.example("example") {}
-          group.run
-          filters.should eq([
-            "around each in config",
-            "before each in config",
-            "after each in config"
-          ])
-        end
-      end
-
-      it "should be ran 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(:match => true)
-        group.example("example") {}
-        group.run
-        filters.should 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
-
-        example_1_filters.should be_empty
-        example_2_filters.should eq([:before_all])
-        filters.should 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
-
-        example_1_filters.should eq([:before_all])
-        example_2_filters.should eq([:before_all])
-        example_3_filters.should eq([:before_all])
-
-        filters.should eq([:before_all, :after_all])
-      end
-
-      it "should not be ran 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
-        filters.should 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
-            each_filters.should eq([
-              'around each in config',
-              'before each in config',
-              'after each in config'
-            ])
-          end
-
-          it "does not run the `:all` hooks" do
-            all_filters.should 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
-            filters.should be_empty
-          end
-        end
-      end
-    end
-
-    describe "hooks with multiple filters" do
-      it "should be ran 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(:one => 1, :two => 2, :three => 3)
-        group.example("example") {}
-        group.run
-        filters.should eq([
-          "before all in config",
-          "around each in config",
-          "before each in config",
-          "after each in config",
-          "after all in config"
-        ])
-      end
-
-      it "should not be ran 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
-        filters.should eq([])
-      end
-    end
-  end
-end

data/spec/rspec/core/hooks_spec.rb

@@ -1,250 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe Hooks do
-    class HooksHost
-      include Hooks
-    end
-
-    [:before, :after, :around].each do |type|
-      [:each, :all].each do |scope|
-        next if type == :around && scope == :all
-
-        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
-
-      [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)
-            RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
-          end
-
-          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
-              instance.hooks[type][:each].should 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
-              instance.hooks[type][:each].should 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
-      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
-              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
-
-              it "does not make #{scope.inspect} a metadata key" do
-                hook.options.should be_empty
-              end
-
-              it "is scoped to #{scope.inspect}" do
-                instance.hooks[type][scope].should include(hook)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    describe "#around" do
-      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 |example|
-            end
-            it "foo" do
-              examples << self
-            end
-          end
-          group.run
-          examples.should have(0).example
-        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
-          examples.should have(1).example
-        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
-          examples.should have(1).example
-        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
-
-          messages.should 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
-
-          messages.should 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
-
-          messages.should 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
-
-          messages.should eq([
-            'group 1',
-            'group 2',
-            'config 1',
-            'config 2',
-            'config 3',
-            'config 4',
-            'group 3',
-            'group 4'
-          ])
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/kernel_extensions_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "extensions" do
-  describe "debugger" do
-    it "is defined on Kernel" do
-      Kernel.should respond_to(:debugger)
-    end
-  end
-end

data/spec/rspec/core/let_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe "#let" do
-  let(:counter) do
-    Class.new do
-      def initialize
-        @count = 0
-      end
-      def count
-        @count += 1
-      end
-    end.new
-  end
-
-  let(:nil_value) do
-    @nil_value_count += 1
-    nil
-  end
-
-  it "generates an instance method" do
-    counter.count.should eq(1)
-  end
-
-  it "caches the value" do
-    counter.count.should eq(1)
-    counter.count.should eq(2)
-  end
-
-  it "caches a nil value" do
-    @nil_value_count = 0
-    nil_value
-    nil_value
-
-    @nil_value_count.should eq(1)
-  end
-end
-
-describe "#let!" do
-  let!(:creator) do
-    Class.new do
-      @count = 0
-      def self.count
-        @count += 1
-      end
-    end
-  end
-
-  it "evaluates the value non-lazily" do
-    lambda { creator.count }.should_not raise_error
-  end
-
-  it "does not interfere between tests" do
-    creator.count.should eq(1)
-  end
-end