rspec-core 2.6.0 → 2.7.0.rc1

data/spec/rspec/core/shared_example_group_spec.rb

@@ -1,8 +1,10 @@
 require 'spec_helper'
 
 module RSpec::Core
-
   describe SharedExampleGroup do
+    
+    ExampleModule = Module.new
+    ExampleClass = Class.new
 
     %w[share_examples_for shared_examples_for].each do |method_name|
       describe method_name do
@@ -17,20 +19,15 @@ module RSpec::Core
             group.send(method_name, 'shared group') {}
           end.should raise_error(ArgumentError, "Shared example group 'shared group' already exists")
         end
-
-        context "given a string" do
-          it "captures the given string and block in the World's collection of shared example groups" do
-            implementation = lambda {}
-            RSpec.world.shared_example_groups.should_receive(:[]=).with("name", implementation)
-            send(method_name, "name", &implementation)
-          end
-        end
-
-        context "given a symbol" do
-          it "captures the given symbol and block in the World's collection of shared example groups" do
-            implementation = lambda {}
-            RSpec.world.shared_example_groups.should_receive(:[]=).with(:name, implementation)
-            send(method_name, :name, &implementation)
+        
+        ["name", :name, ExampleModule, ExampleClass].each do |object|
+          type = object.class.name.downcase
+          context "given a #{type}" do
+            it "captures the given #{type} and block in the World's collection of shared example groups" do
+              implementation = lambda {}
+              RSpec.world.shared_example_groups.should_receive(:[]=).with(object, implementation)
+              send(method_name, object, &implementation)
+            end
           end
         end
 
@@ -64,107 +61,6 @@ module RSpec::Core
       end
     end
 
-    describe "#it_should_behave_like" do
-      it "creates a nested group" do
-        shared_examples_for("thing") {}
-        group = ExampleGroup.describe('fake group')
-        group.it_should_behave_like("thing")
-        group.should have(1).children
-      end
-
-      it "adds shared examples to nested group" do
-        shared_examples_for("thing") do
-          it("does something")
-        end
-        group = ExampleGroup.describe('fake group')
-        shared_group = group.it_should_behave_like("thing")
-        shared_group.should have(1).examples
-      end
-
-      it "adds shared instance methods to nested group" do
-        shared_examples_for("thing") do
-          def foo; end
-        end
-        group = ExampleGroup.describe('fake group')
-        shared_group = group.it_should_behave_like("thing")
-        shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
-      end
-
-      it "adds shared class methods to nested group" do
-        shared_examples_for("thing") do
-          def self.foo; end
-        end
-        group = ExampleGroup.describe('fake group')
-        shared_group = group.it_should_behave_like("thing")
-        shared_group.methods.map{|m| m.to_s}.should include("foo")
-      end
-
-      context "given some parameters" do
-        it "passes the parameters to the shared example group" do
-          passed_params = {}
-
-          shared_examples_for("thing") do |param1, param2|
-            it("has access to the given parameters") do
-              passed_params[:param1] = param1
-              passed_params[:param2] = param2
-            end
-          end
-
-          group = ExampleGroup.describe("group") do
-            it_should_behave_like "thing", :value1, :value2
-          end
-          group.run
-
-          passed_params.should == { :param1 => :value1, :param2 => :value2 }
-        end
-
-        it "adds shared instance methods to nested group" do
-          shared_examples_for("thing") do |param1|
-            def foo; end
-          end
-          group = ExampleGroup.describe('fake group')
-          shared_group = group.it_should_behave_like("thing", :a)
-          shared_group.public_instance_methods.map{|m| m.to_s}.should include("foo")
-        end
-
-        it "evals the shared example group only once" do
-          eval_count = 0
-          shared_examples_for("thing") { |p| eval_count += 1 }
-          group = ExampleGroup.describe('fake group')
-          shared_group = group.it_should_behave_like("thing", :a)
-          eval_count.should == 1
-        end
-      end
-
-      context "given a block" do
-        it "evaluates the block in nested group" do
-          scopes = []
-          shared_examples_for("thing") do
-            it("gets run in the nested group") do
-              scopes << self.class
-            end
-          end
-          group = ExampleGroup.describe("group") do
-            it_should_behave_like "thing" do
-              it("gets run in the same nested group") do
-                scopes << self.class
-              end
-            end
-          end
-          group.run
-
-          scopes[0].should be(scopes[1])
-        end
-      end
-
-      it "raises when named shared example_group can not be found" do
-        group = ExampleGroup.describe("example_group")
-        lambda do
-          group.it_should_behave_like("a group that does not exist")
-        end.should raise_error(/Could not find shared example group named/)
-      end
-    end
-
     describe "#share_as" do
       it "is exposed to the global namespace" do
         Kernel.should respond_to("share_as")
@@ -173,15 +69,15 @@ module RSpec::Core
       it "adds examples to current example_group using include", :compat => 'rspec-1.2' do
         share_as('Cornucopia') do
           it "is plentiful" do
-            5.should == 4
+            5.should eq(4)
           end
         end
         group = ExampleGroup.describe('group') { include Cornucopia }
         phantom_group = group.children.first
         phantom_group.description.should eql("")
         phantom_group.metadata[:shared_group_name].should eql('Cornucopia')
-        phantom_group.examples.length.should == 1
-        phantom_group.examples.first.metadata[:description].should == "is plentiful"
+        phantom_group.examples.length.should eq(1)
+        phantom_group.examples.first.metadata[:description].should eq("is plentiful")
       end
     end
   end

data/spec/rspec/core/subject_spec.rb

@@ -8,25 +8,25 @@ module RSpec::Core
     describe "implicit subject" do
       describe "with a class" do
         it "returns an instance of the class" do
-          ExampleGroup.describe(Array).subject.call.should == []
+          ExampleGroup.describe(Array).subject.call.should eq([])
         end
       end
 
       describe "with a Module" do
         it "returns the Module" do
-          ExampleGroup.describe(Enumerable).subject.call.should == Enumerable
+          ExampleGroup.describe(Enumerable).subject.call.should eq(Enumerable)
         end
       end
 
       describe "with a string" do
         it "return the string" do
-          ExampleGroup.describe("Foo").subject.call.should == 'Foo'
+          ExampleGroup.describe("Foo").subject.call.should eq("Foo")
         end
       end
 
       describe "with a number" do
         it "returns the number" do
-          ExampleGroup.describe(15).subject.call.should == 15
+          ExampleGroup.describe(15).subject.call.should eq(15)
         end
       end
 
@@ -56,7 +56,7 @@ module RSpec::Core
         it "replaces the implicit subject in that group" do
           group = ExampleGroup.describe(Array)
           group.subject { [1,2,3] }
-          group.subject.call.should == [1,2,3]
+          group.subject.call.should eq([1,2,3])
         end
       end
 
@@ -69,13 +69,13 @@ module RSpec::Core
 
         it "is available in a nested group (subclass)" do
           nested_group = group.describe("I'm nested!") { }
-          nested_group.subject.call.should == [4,5,6]
+          nested_group.subject.call.should eq([4,5,6])
         end
 
         it "is available in a doubly nested group (subclass)" do
           nested_group = group.describe("Nesting level 1") { }
           doubly_nested_group = nested_group.describe("Nesting level 2") { }
-          doubly_nested_group.subject.call.should == [4,5,6]
+          doubly_nested_group.subject.call.should eq([4,5,6])
         end
       end
     end
@@ -149,9 +149,9 @@ module RSpec::Core
             end
           end.new
         end
-        its([:a]) { should == 'Symbol: a' }
-        its(['a']) { should == 'String: a' }
-        its([:b, 'c', 4]) { should == 'Symbol: b; String: c; Fixnum: 4' }
+        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 = "George" }
         context "when referring to an attribute without the proper array syntax" do
           context "it raises an error" do
@@ -170,7 +170,7 @@ module RSpec::Core
         context "it raises an error" do
           its([:a]) do
             expect do
-              should == 'Symbol: a'
+              should eq("Symbol: a")
             end.to raise_error(NoMethodError)
           end
         end
@@ -181,12 +181,12 @@ module RSpec::Core
           group = ExampleGroup.describe(Array) do
             subject { [1, 'a'] }
 
-            its(:last) { should == 'a' }
+            its(:last) { should eq("a") }
 
             describe '.first' do
               def subject; super().first; end
 
-              its(:next) { should == 2 }
+              its(:next) { should eq(2) }
             end
           end
 

data/spec/rspec/core/world_spec.rb

@@ -49,35 +49,35 @@ module RSpec::Core
       let(:example_groups) { [group1, group2, group3, group4] }
 
       it "finds no groups when given no search parameters" do
-        world.apply_inclusion_filters([]).should == []
+        world.apply_inclusion_filters([],{}).should eq([])
       end
 
       it "finds matching groups when filtering on :describes (described class or module)" do
-        world.apply_inclusion_filters(example_groups, :example_group => { :describes => Bar }).should == [group1, group2, group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :describes => Bar }).should eq([group1, group2, group3])
       end
 
       it "finds matching groups when filtering on :description with text" do
-        world.apply_inclusion_filters(example_groups, :example_group => { :description => 'Bar find group-1' }).should == [group1]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => 'Bar find group-1' }).should eq([group1])
       end
 
       it "finds matching groups when filtering on :description with a lambda" do
-        world.apply_inclusion_filters(example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [group1, group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should eq([group1, group3])
       end
 
       it "finds matching groups when filtering on :description with a regular expression" do
-        world.apply_inclusion_filters(example_groups, :example_group => { :description => /find group/ }).should == [group1, group2, group3]
+        world.apply_inclusion_filters(example_groups, :example_group => { :description => /find group/ }).should eq([group1, group2, group3])
       end
 
       it "finds one group when searching for :pending => true" do
-        world.apply_inclusion_filters(example_groups, :pending => true ).should == [group2]
+        world.apply_inclusion_filters(example_groups, :pending => true ).should eq([group2])
       end
 
       it "finds matching groups when filtering on arbitrary metadata with a number" do
-        world.apply_inclusion_filters(example_groups, :foo => 1 ).should == [group1]
+        world.apply_inclusion_filters(example_groups, :foo => 1 ).should eq([group1])
       end
 
       it "finds matching groups when filtering on arbitrary metadata with an array" do
-        world.apply_inclusion_filters(example_groups, :array => [1,2,3,4]).should == [group3]
+        world.apply_inclusion_filters(example_groups, :array => [1,2,3,4]).should eq([group3])
       end
 
       it "finds no groups when filtering on arbitrary metadata with an array but the arrays do not match" do
@@ -85,11 +85,11 @@ module RSpec::Core
       end
 
       it "finds matching examples when filtering on arbitrary metadata" do
-        world.apply_inclusion_filters(group4.examples, :awesome => true).should == [group4.examples[1], group4.examples[2]]
+        world.apply_inclusion_filters(group4.examples, :awesome => true).should eq([group4.examples[1], group4.examples[2]])
       end
 
       it "finds matching examples for example that match any of the filters" do
-        world.apply_inclusion_filters(group4.examples, :awesome => true, :something => :else).should == [group4.examples[1], group4.examples[2]]
+        world.apply_inclusion_filters(group4.examples, :awesome => true, :something => :else).should eq([group4.examples[1], group4.examples[2]])
       end
     end
 
@@ -105,7 +105,7 @@ module RSpec::Core
 
         world.register(group1)
 
-        world.apply_exclusion_filters(group1.examples, :network_access => true).should == []
+        world.apply_exclusion_filters(group1.examples, :network_access => true).should eq([])
 
         group2 = ExampleGroup.describe(Bar, "find group-1") do
           it("foo", :network_access => true) {}
@@ -114,7 +114,7 @@ module RSpec::Core
 
         world.register(group2)
 
-        world.apply_exclusion_filters(group2.examples, :network_access => true).should == [group2.examples.last]
+        world.apply_exclusion_filters(group2.examples, :network_access => true).should eq([group2.examples.last])
       end
 
       it "finds nothing if a regexp matches the exclusion filter" do
@@ -123,14 +123,23 @@ module RSpec::Core
           it("bar") {}
         end
         world.register(group)
-        world.apply_exclusion_filters(group.examples, :name => /exclude/).should == []
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude/).should eq([])
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo").should eq([])
         world.apply_exclusion_filters(group.examples, :name => /exclude/, :another => "foo", :example_group => {
-          :describes => lambda { |b| b == Bar } } ).should == []
+          :describes => lambda { |b| b == Bar } } ).should eq([])
 
-        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should == group.examples
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should == []
-        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should == []
+        world.apply_exclusion_filters(group.examples, :name => /exclude not/).should eq(group.examples)
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo").should eq([])
+        world.apply_exclusion_filters(group.examples, :name => /exclude/, "another_condition" => "foo1").should eq([])
+      end
+
+      it "finds all if filters are empty" do
+        group = ExampleGroup.describe(Bar) do
+          example("foo") {}
+          example("bar") {}
+        end
+        world.register(group)
+        world.apply_exclusion_filters(group.examples, {}).should eq(group.examples)
       end
     end
 
@@ -269,22 +278,22 @@ module RSpec::Core
     describe "#exclusion_filter" do
       describe "#description" do
         it 'returns `{}` when it only contains the default filters' do
-          world.exclusion_filter.description.should == {}.inspect
+          world.exclusion_filter.description.should eq({}.inspect)
         end
 
         it 'includes other filters' do
           configuration.exclusion_filter[:foo] = :bar
-          world.exclusion_filter.description.should == { :foo => :bar }.inspect
+          world.exclusion_filter.description.should eq({ :foo => :bar }.inspect)
         end
 
         it 'includes an overriden :if filter' do
           configuration.exclusion_filter[:if] = :custom_filter
-          world.exclusion_filter.description.should == { :if => :custom_filter }.inspect
+          world.exclusion_filter.description.should eq({ :if => :custom_filter }.inspect)
         end
 
         it 'includes an overriden :unless filter' do
           configuration.exclusion_filter[:unless] = :custom_filter
-          world.exclusion_filter.description.should == { :unless => :custom_filter }.inspect
+          world.exclusion_filter.description.should eq({ :unless => :custom_filter }.inspect)
         end
 
         it 'cleans up the description' do

data/spec/rspec/core_spec.rb

@@ -11,41 +11,13 @@ describe RSpec::Core do
   end
 
   describe "#configure" do
-    around(:each) do |example|
-      RSpec.allowing_configure_warning(&example)
-    end
-
-    before(:each) do
-      RSpec.stub(:warn)
-    end
 
     it "yields the current configuration" do
       RSpec.configure do |config|
-        config.should == RSpec::configuration
-      end
-    end
-
-    context "when an example group has already been defined" do
-      before(:each) do
-        RSpec.world.stub(:example_groups).and_return([double.as_null_object])
-      end
-
-      it "prints a deprecation warning" do
-        RSpec.should_receive(:warn).with(/configuration should happen before the first example group/)
-        RSpec.configure { |c| }
+        config.should eq(RSpec::configuration)
       end
     end
 
-    context "when no examples have been defined yet" do
-      before(:each) do
-        RSpec.world.stub(:example_groups).and_return([])
-      end
-
-      it "does not print a deprecation warning" do
-        RSpec.should_not_receive(:warn)
-        RSpec.configure { |c| }
-      end
-    end
   end
 
   describe "#world" do

data/spec/spec_helper.rb

@@ -1,39 +1,55 @@
-require 'rspec/core'
-require 'autotest/rspec2'
+require 'rubygems'
 
-Dir['./spec/support/**/*.rb'].map {|f| require f}
+begin
+  require 'spork'
+rescue LoadError
+  module Spork
+    def self.prefork
+      yield
+    end
 
-class NullObject
-  private
-  def method_missing(method, *args, &block)
-    # ignore
+    def self.each_run
+      yield
+    end
   end
 end
 
-def sandboxed(&block)
-  begin
-    @orig_config = RSpec.configuration
-    @orig_world  = RSpec.world
-    new_config = RSpec::Core::Configuration.new
-    new_world  = RSpec::Core::World.new(new_config)
-    RSpec.instance_variable_set(:@configuration, new_config)
-    RSpec.instance_variable_set(:@world, new_world)
-    object = Object.new
-    object.extend(RSpec::Core::ObjectExtensions)
-    object.extend(RSpec::Core::SharedExampleGroup)
+Spork.prefork do
+  require 'rspec/autorun'
+  require 'autotest/rspec2'
 
-    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
-      alias_method :orig_run, :run
-      def run(reporter=nil)
-        @orig_mock_space = RSpec::Mocks::space
-        RSpec::Mocks::space = RSpec::Mocks::Space.new
-        orig_run(reporter || NullObject.new)
-      ensure
-        RSpec::Mocks::space = @orig_mock_space
-      end
+  Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+  class NullObject
+    private
+    def method_missing(method, *args, &block)
+      # ignore
     end
+  end
 
-    object.instance_eval(&block)
+  def sandboxed(&block)
+    begin
+      @orig_config = RSpec.configuration
+      @orig_world  = RSpec.world
+      new_config = RSpec::Core::Configuration.new
+      new_world  = RSpec::Core::World.new(new_config)
+      RSpec.instance_variable_set(:@configuration, new_config)
+      RSpec.instance_variable_set(:@world, new_world)
+      object = Object.new
+      object.extend(RSpec::Core::SharedExampleGroup)
+
+      (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+        alias_method :orig_run, :run
+        def run(reporter=nil)
+          @orig_mock_space = RSpec::Mocks::space
+          RSpec::Mocks::space = RSpec::Mocks::Space.new
+          orig_run(reporter || NullObject.new)
+        ensure
+          RSpec::Mocks::space = @orig_mock_space
+        end
+      end
+
+      object.instance_eval(&block)
   ensure
     (class << RSpec::Core::ExampleGroup; self; end).class_eval do
       remove_method :run
@@ -43,34 +59,13 @@ def sandboxed(&block)
 
     RSpec.instance_variable_set(:@configuration, @orig_config)
     RSpec.instance_variable_set(:@world, @orig_world)
-  end
+end
 end
 
 def in_editor?
   ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
 end
 
-class << RSpec
-  alias_method :original_warn_about_deprecated_configure, :warn_about_deprecated_configure
-
-  def warn_about_deprecated_configure
-    # no-op: in our specs we don't want to see the warning.
-  end
-
-  alias_method :null_warn_about_deprecated_configure, :warn_about_deprecated_configure
-
-  def allowing_configure_warning
-    (class << self; self; end).class_eval do
-      alias_method :warn_about_deprecated_configure, :original_warn_about_deprecated_configure
-      begin
-        yield
-      ensure
-        alias_method :warn_about_deprecated_configure, :null_warn_about_deprecated_configure
-      end
-    end
-  end
-end
-
 RSpec.configure do |c|
   c.color_enabled = !in_editor?
   c.filter_run :focus => true
@@ -85,7 +80,13 @@ RSpec.configure do |c|
       !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
     end
   }
+  c.alias_it_should_behave_like_to 'it_has_behavior'
   c.around do |example|
     sandboxed { example.run }
   end
 end
+end
+
+Spork.each_run do
+end
+

data/spec/support/shared_example_groups.rb

@@ -7,12 +7,12 @@ shared_examples_for "metadata hash builder" do
     end
 
     it 'treats symbols as metadata keys with a true value' do
-      hash[:foo].should == true
-      hash[:bar].should == true
+      hash[:foo].should be(true)
+      hash[:bar].should be(true)
     end
 
     it 'still processes hash values normally' do
-      hash[:bazz].should == 23
+      hash[:bazz].should be(23)
     end
   end
 

data/spec/support/spec_files.rb

@@ -10,11 +10,11 @@ shared_context "spec files" do
   def create_passing_spec_file
     File.open(passing_spec_filename, 'w') do |f|
       f.write %q{
-          describe "passing spec" do
-            it "passes" do
-              1.should eq(1)
-            end
+        describe "passing spec" do
+          it "passes" do
+            1.should eq(1)
           end
+        end
       }
     end
   end
@@ -22,11 +22,11 @@ shared_context "spec files" do
   def create_failing_spec_file
     File.open(failing_spec_filename, 'w') do |f|
       f.write %q{
-          describe "failing spec" do
-            it "fails" do
-              1.should eq(2)
-            end
+        describe "failing spec" do
+          it "fails" do
+            1.should eq(2)
           end
+        end
       }
     end
   end