rspec-core 2.5.1 → 2.6.0

data/spec/rspec/core/runner_spec.rb

@@ -21,25 +21,57 @@ module RSpec::Core
     end
 
     describe "#run" do
+      let(:err) { StringIO.new }
+      let(:out) { StringIO.new }
+
+      it "resets world and configuration" do
+        RSpec.configuration.should_receive(:reset)
+        RSpec.world.should_receive(:reset)
+        RSpec::Core::Runner.run([], err, out)
+      end
+
       context "with --drb or -X" do
-        before(:each) do
-          @err = @out = StringIO.new
 
+        before(:each) do
           @options = RSpec::Core::ConfigurationOptions.new(%w[--drb --drb-port 8181 --color])
           RSpec::Core::ConfigurationOptions.stub(:new) { @options }
+        end
 
-          @drb_proxy = double(RSpec::Core::DRbCommandLine, :run => true)
-          RSpec::Core::DRbCommandLine.stub(:new => @drb_proxy)
+        def run_specs
+          RSpec::Core::Runner.run(%w[ --drb ], err, out)
         end
 
-        it "builds a DRbCommandLine" do
-          RSpec::Core::DRbCommandLine.should_receive(:new)
-          RSpec::Core::Runner.run(%w[ --drb ], @err, @out)
+        context 'and a DRb server is running' do
+          it "builds a DRbCommandLine and runs the specs" do
+            drb_proxy = double(RSpec::Core::DRbCommandLine, :run => true)
+            drb_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_return(drb_proxy)
+
+            run_specs
+          end
         end
 
-        it "runs specs over the proxy" do
-          @drb_proxy.should_receive(:run).with(@err, @out)
-          RSpec::Core::Runner.run(%w[ --drb ], @err, @out)
+        context 'and a DRb server is not running' do
+          before(:each) do
+            RSpec::Core::DRbCommandLine.should_receive(:new).and_raise(DRb::DRbConnError)
+          end
+
+          it "outputs a message" do
+            err.should_receive(:puts).with(
+              "No DRb server is running. Running in local process instead ..."
+            )
+            run_specs
+          end
+
+          it "builds a CommandLine and runs the specs" do
+            process_proxy = double(RSpec::Core::CommandLine, :run => true)
+            process_proxy.should_receive(:run).with(err, out)
+
+            RSpec::Core::CommandLine.should_receive(:new).and_return(process_proxy)
+
+            run_specs
+          end
         end
       end
     end

data/spec/rspec/core/shared_example_group_spec.rb

@@ -6,7 +6,6 @@ module RSpec::Core
 
     %w[share_examples_for shared_examples_for].each do |method_name|
       describe method_name do
-
         it "is exposed to the global namespace" do
           Kernel.should respond_to(method_name)
         end
@@ -19,32 +18,49 @@ module RSpec::Core
           end.should raise_error(ArgumentError, "Shared example group 'shared group' already exists")
         end
 
-        it "captures the given name and block in the Worlds collection of shared example groups" do
-          implementation = lambda {}
-          RSpec.world.shared_example_groups.should_receive(:[]=).with(:foo, implementation)
-          send(method_name, :foo, &implementation)
+        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
 
-      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)
+          end
+        end
 
-    describe "#share_as" do
-      it "is exposed to the global namespace" do
-        Kernel.should respond_to("share_as")
-      end
+        context "given a hash" do
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
+          end
+        end
 
-      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
+        context "given a string and a hash" 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", :foo => :bar, &implementation)
+          end
+
+          it "delegates extend on configuration" do
+            implementation = Proc.new { def bar; 'bar'; end }
+            send(method_name, "name", :foo => :bar, &implementation)
+            a = RSpec.configuration.include_or_extend_modules.first
+            a[0].should eq(:extend)
+            Class.new.extend(a[1]).new.bar.should eq('bar')
+            a[2].should eq(:foo => :bar)
           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"
       end
     end
 
@@ -148,5 +164,25 @@ module RSpec::Core
         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")
+      end
+
+      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
+          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"
+      end
+    end
   end
 end

data/spec/rspec/core/subject_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 module RSpec::Core
 
   describe Subject do
+    before(:each) { RSpec.configuration.configure_expectation_framework }
 
     describe "implicit subject" do
       describe "with a class" do
@@ -134,27 +135,47 @@ module RSpec::Core
         its("name.size.class") { should eq(Fixnum) }
       end
 
-      context "when it is a Hash" do
+      context "when it responds to #[]" do
         subject do
-          { :attribute => 'value',
-            'another_attribute' => 'another_value' }
-        end
-        its([:attribute]) { should == 'value' }
-        its([:attribute]) { should_not == 'another_value' }
-        its([:another_attribute]) { should == 'another_value' }
-        its([:another_attribute]) { should_not == 'value' }
-        its(:keys) { should =~ ['another_attribute', :attribute] }
+          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 == 'Symbol: a' }
+        its(['a']) { should == 'String: a' }
+        its([:b, 'c', 4]) { should == '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
-            its(:attribute) do
+            its(:age) do
               expect do
-                should eq('value')
+                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 == '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

data/spec/rspec/core/world_spec.rb

@@ -5,8 +5,9 @@ class Foo; end
 
 module RSpec::Core
 
-  describe World do
-    let(:world) { RSpec::Core::World.new }
+  describe RSpec::Core::World do
+    let(:configuration) { RSpec::Core::Configuration.new }
+    let(:world) { RSpec::Core::World.new(configuration) }
 
     describe "#example_groups" do
       it "contains all registered example groups" do
@@ -138,7 +139,15 @@ module RSpec::Core
       let(:group) do
         RSpec::Core::ExampleGroup.describe("group") do
 
-          example("example") {}
+            example("example") {}
+
+        end
+      end
+
+      let(:second_group) do
+        RSpec::Core::ExampleGroup.describe("second_group") do
+
+          example("second_example") {}
 
         end
       end
@@ -146,29 +155,152 @@ module RSpec::Core
       let(:group_declaration_line) { group.metadata[:example_group][:line_number] }
       let(:example_declaration_line) { group_declaration_line + 2 }
 
-      before { world.register(group) }
+      context "with one example" do
+        before { world.register(group) }
+
+        it "returns nil if no example or group precedes the line" do
+          world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+        end
+
+        it "returns the argument line number if a group starts on that line" do
+          world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+        end
+
+        it "returns the argument line number if an example starts on that line" do
+          world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+        end
+
+        it "returns line number of a group that immediately precedes the argument line" do
+          world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+        end
 
-      it "returns nil if no example or group precedes the line" do
-        world.preceding_declaration_line(group_declaration_line - 1).should be_nil
+        it "returns line number of an example that immediately precedes the argument line" do
+          world.preceding_declaration_line(example_declaration_line + 1).should eq(example_declaration_line)
+        end
       end
 
-      it "returns the argument line number if a group starts on that line" do
-        world.preceding_declaration_line(group_declaration_line).should eq(group_declaration_line)
+      context "with two exaples and the second example is registre first" do
+        let(:second_group_declaration_line) { second_group.metadata[:example_group][:line_number] }
+
+        before do 
+          world.register(second_group)
+          world.register(group)
+        end
+
+        it 'return line number of group if a group start on that line' do
+          world.preceding_declaration_line(second_group_declaration_line).should eq(second_group_declaration_line)
+        end
       end
+    end
+
+    describe "#announce_filters" do
+      let(:reporter) { double('reporter').as_null_object }
+      before { world.stub(:reporter) { reporter } }
+
+      context "with no examples" do
+        before { world.stub(:example_count) { 0 } }
+
+        context "with no filters" do
+          it "announces" do
+            reporter.should_receive(:message).
+              with("No examples found.")
+            world.announce_filters
+          end
+        end
+
+        context "with an inclusion filter" do
+          it "announces" do
+            configuration.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}.")
+            world.announce_filters
+          end
+        end
 
-      it "returns the argument line number if an example starts on that line" do
-        world.preceding_declaration_line(example_declaration_line).should eq(example_declaration_line)
+        context "with an inclusion filter and run_all_when_everything_filtered" do
+          it "announces" do
+            configuration.stub(:run_all_when_everything_filtered?) { true }
+            configuration.inclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples matched #{{ :foo => 'bar' }.inspect}. Running all.")
+            world.announce_filters
+          end
+        end
+
+        context "with an exclusion filter" do
+          it "announces" do
+            configuration.exclusion_filter = { :foo => 'bar' }
+            reporter.should_receive(:message).
+              with("No examples were matched. Perhaps #{{ :foo => 'bar' }.inspect} is excluding everything?")
+            world.announce_filters
+          end
+        end
       end
 
-      it "returns line number of a group that immediately precedes the argument line" do
-        world.preceding_declaration_line(group_declaration_line + 1).should eq(group_declaration_line)
+      context "with examples" do
+        before { world.stub(:example_count) { 1 } }
+
+        context "with no filters" do
+          it "does not announce" do
+            reporter.should_not_receive(:message)
+            world.announce_filters
+          end
+        end
       end
+    end
 
-      it "returns line number of an example that immediately precedes the argument line" do
-        world.preceding_declaration_line(example_declaration_line + 1).should eq(example_declaration_line)
+    describe "#inclusion_filter" do
+      describe "#description" do
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.filter_run :foo => lambda { }
+          world.inclusion_filter.description.should_not include('0x')
+          world.inclusion_filter.description.should_not include(project_dir)
+          world.inclusion_filter.description.should_not include(' (lambda)')
+        end
       end
     end
 
-  end
+    describe "#exclusion_filter" do
+      describe "#description" do
+        it 'returns `{}` when it only contains the default filters' do
+          world.exclusion_filter.description.should == {}.inspect
+        end
+
+        it 'includes other filters' do
+          configuration.exclusion_filter[:foo] = :bar
+          world.exclusion_filter.description.should == { :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
+        end
+
+        it 'includes an overriden :unless filter' do
+          configuration.exclusion_filter[:unless] = :custom_filter
+          world.exclusion_filter.description.should == { :unless => :custom_filter }.inspect
+        end
+
+        it 'cleans up the description' do
+          # check the assumptions of this example
+          project_dir = File.expand_path('.')
+          lambda { }.inspect.should include(project_dir)
+          lambda { }.inspect.should include('0x')
+          lambda { }.inspect.should include(' (lambda)') if RUBY_VERSION > '1.9'
+
+          configuration.exclusion_filter[:foo] = lambda { }
+          configuration.filter_run_excluding :bar => lambda { }
+          world.exclusion_filter.description.should_not include('0x')
+          world.exclusion_filter.description.should_not include(project_dir)
+          world.exclusion_filter.description.should_not include(' (lambda)')
+        end
+      end
+    end
+  end
 end

data/spec/rspec/core_spec.rb

@@ -11,6 +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|
@@ -18,6 +25,27 @@ describe RSpec::Core do
       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| }
+      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

@@ -15,7 +15,6 @@ def sandboxed(&block)
     @orig_config = RSpec.configuration
     @orig_world  = RSpec.world
     new_config = RSpec::Core::Configuration.new
-    new_config.include(RSpec::Matchers)
     new_world  = RSpec::Core::World.new(new_config)
     RSpec.instance_variable_set(:@configuration, new_config)
     RSpec.instance_variable_set(:@world, new_world)
@@ -51,6 +50,27 @@ 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
@@ -58,7 +78,7 @@ RSpec.configure do |c|
   c.filter_run_excluding :ruby => lambda {|version|
     case version.to_s
     when "!jruby"
-      RUBY_ENGINE != "jruby"
+      RUBY_ENGINE == "jruby"
     when /^> (.*)/
       !(RUBY_VERSION.to_s > $1)
     else

data/spec/support/matchers.rb

@@ -20,25 +20,56 @@ RSpec::Matchers.define :map_specs do |specs|
   end
 end
 
-RSpec::Matchers.define :have_interface_for do |method|
-  match do |object|
-    @method = method
-    @object = object
-    object.respond_to?(method) && actual_arity == @expected_arity
+RSpec::Matchers.define :be_pending_with do |message|
+  match do |example|
+    example.metadata[:pending] && example.metadata[:execution_result][:pending_message] == message
   end
 
-  chain :with do |arity|
-    @expected_arity = arity
+  failure_message_for_should do |example|
+    "expected example to pending with #{message.inspect}, got #{example.metadata[:execution_result][:pending_message].inspect}"
   end
+end
 
-  chain(:argument) {}
-  chain(:arguments) {}
+RSpec::Matchers.define :fail_with do |exception_klass|
+  match do |example|
+    failure_reason(example, exception_klass).nil?
+  end
 
-  failure_message_for_should do
-    "#{@object} should have method :#{@method} with #{@expected_arity} argument(s), but it had #{actual_arity}"
+  failure_message_for_should do |example|
+    "expected example to fail with a #{exception_klass} exception, but #{failure_reason(example, exception_klass)}"
+  end
+
+  def failure_reason(example, exception_klass)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'failed' then result[:status]
+      when !result[:exception].is_a?(exception_klass) then "failed with a #{result[:exception].class}"
+      else nil
+    end
+  end
+end
+
+RSpec::Matchers.define :pass do
+  match do |example|
+    failure_reason(example).nil?
+  end
+
+  failure_message_for_should do |example|
+    "expected example to pass, but #{failure_reason(example)}"
   end
 
-  def actual_arity
-    @object.method(@method).arity
+  def failure_reason(example)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'passed' then result[:status]
+      else nil
+    end
   end
 end
+
+RSpec::Matchers.module_eval do
+  alias have_failed_with fail_with
+  alias have_passed pass
+end

data/spec/support/shared_example_groups.rb

@@ -0,0 +1,41 @@
+shared_examples_for "metadata hash builder" do
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true" do
+    let(:hash) { metadata_hash(:foo, :bar, :bazz => 23) }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+    end
+
+    it 'treats symbols as metadata keys with a true value' do
+      hash[:foo].should == true
+      hash[:bar].should == true
+    end
+
+    it 'still processes hash values normally' do
+      hash[:bazz].should == 23
+    end
+  end
+
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false" do
+    let(:warning_receiver) { Kernel }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
+      warning_receiver.stub(:warn)
+    end
+
+    it 'prints a deprecation warning about any symbols given as arguments' do
+      warning_receiver.should_receive(:warn).with(/In RSpec 3, these symbols will be treated as metadata keys/)
+      metadata_hash(:foo, :bar, :key => 'value')
+    end
+
+    it 'does not treat symbols as metadata keys' do
+      metadata_hash(:foo, :bar, :key => 'value').should_not include(:foo, :bar)
+    end
+
+    it 'does not print a warning if there are no symbol arguments' do
+      warning_receiver.should_not_receive(:warn)
+      metadata_hash(:foo => 23, :bar => 17)
+    end
+  end
+end

data/spec/support/spec_files.rb

@@ -0,0 +1,44 @@
+shared_context "spec files" do
+  def failing_spec_filename
+    @failing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_failing_spec.rb"
+  end
+
+  def passing_spec_filename
+    @passing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_passing_spec.rb"
+  end
+
+  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
+          end
+      }
+    end
+  end
+
+  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
+          end
+      }
+    end
+  end
+
+  before(:all) do
+    create_passing_spec_file
+    create_failing_spec_file
+  end
+
+  after(:all) do
+    File.delete(passing_spec_filename)
+    File.delete(failing_spec_filename)
+  end
+
+end