rspec-core 2.5.2 → 2.6.0.rc2

data/spec/rspec/core/metadata_spec.rb

@@ -240,13 +240,13 @@ module RSpec
 
         %w[# . ::].each do |char|
           context "with a nested description starting with #{char}" do
-          it "removes the space" do
-            parent = Metadata.new
-            parent.process("Object")
-            child = Metadata.new(parent)
-            child.process("#{char}method")
-            child[:example_group][:full_description].should eq("Object#{char}method")
-          end
+            it "removes the space" do
+              parent = Metadata.new
+              parent.process("Object")
+              child = Metadata.new(parent)
+              child.process("#{char}method")
+              child[:example_group][:full_description].should eq("Object#{char}method")
+            end
           end
         end
       end

data/spec/rspec/core/option_parser_spec.rb

@@ -71,5 +71,13 @@ module RSpec::Core
         end
       end
     end
+
+    describe "--example" do
+      it "escapes the arg" do
+        options = Parser.parse!(["--example", "this (and that)"])
+        "this (and that)".should match(options[:full_description])
+      end
+    end
+
   end
 end

data/spec/rspec/core/pending_example_spec.rb

@@ -1,54 +1,5 @@
 require 'spec_helper'
 
-RSpec::Matchers.define :be_pending_with do |message|
-  match do |example|
-    example.metadata[:pending] && example.metadata[:execution_result][:pending_message] == message
-  end
-
-  failure_message_for_should do |example|
-    "expected example to pending with #{message.inspect}, got #{example.metadata[:execution_result][:pending_message].inspect}"
-  end
-end
-
-RSpec::Matchers.define :fail_with do |exception_klass|
-  match do |example|
-    failure_reason(example, exception_klass).nil?
-  end
-
-  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 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
-
 describe "an example" do
   context "with no block" do
     it "is listed as pending with 'Not Yet Implemented'" do
@@ -121,10 +72,10 @@ describe "an example" do
   end
 
   context "with a block" do
-    def run_example(*pending_args)
+    def run_example(*pending_args, &block)
       group = RSpec::Core::ExampleGroup.describe('group') do
         it "does something" do
-          pending(*pending_args) { yield }
+          pending(*pending_args) { block.call if block }
         end
       end
       example = group.examples.first
@@ -182,6 +133,16 @@ describe "an example" do
       end
     end
 
+    context "that fails due to a failed message expectation" do
+      def run_example(*pending_args)
+        super(*pending_args) { "foo".should_receive(:bar) }
+      end
+
+      it "passes" do
+        run_example("just because").should be_pending
+      end
+    end
+
     context "that passes" do
       def run_example(*pending_args)
         super(*pending_args) { 3.should == 3 }

data/spec/rspec/core/reporter_spec.rb

@@ -30,13 +30,17 @@ module RSpec::Core
       it "passes example_group_started and example_group_finished messages to that formatter in that order" do
         order = []
 
-        formatter = stub("formatter")
+        formatter = stub("formatter").as_null_object
         formatter.stub(:example_group_started) { |group| order << "Started: #{group.description}" }
         formatter.stub(:example_group_finished) { |group| order << "Finished: #{group.description}" }
 
         group = ExampleGroup.describe("root")
-        group.describe("context 1")
-        group.describe("context 2")
+        group.describe("context 1") do
+          example("ignore") {}
+        end
+        group.describe("context 2") do
+          example("ignore") {}
+        end
 
         group.run(Reporter.new(formatter))
 
@@ -51,6 +55,18 @@ module RSpec::Core
       end
     end
 
+    context "given an example group with no examples" do
+      it "does not pass example_group_started or example_group_finished to formatter" do
+        formatter = stub("formatter").as_null_object
+        formatter.should_not_receive(:example_group_started)
+        formatter.should_not_receive(:example_group_finished)
+
+        group = ExampleGroup.describe("root")
+
+        group.run(Reporter.new(formatter))
+      end
+    end
+
     context "given multiple formatters" do
       it "passes messages to all formatters" do
         formatters = [double("formatter"), double("formatter")]

data/spec/rspec/core/resources/formatter_specs.rb

@@ -48,7 +48,13 @@ describe "a failing spec with odd backtraces" do
       ["/foo.html.erb:1:in `<main>': foo (RuntimeError)",
         "   from /lib/ruby/1.9.1/erb.rb:753:in `eval'"]
     end
-
+    
+    def e.message
+      # Redefining message steps around this behaviour 
+      # on JRuby: http://jira.codehaus.org/browse/JRUBY-5637
+      self.class.name
+    end
+    
     raise e
   end
 end

data/spec/rspec/core/rspec_matchers_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module RSpec::Matchers
+  def __method_with_super
+    super
+  end
+
+  module ModThatIncludesMatchers
+    include RSpec::Matchers
+  end
+
+  RSpec.configure do |c|
+    c.include RSpec::Matchers, :include_rspec_matchers => true
+    c.include ModThatIncludesMatchers, :include_mod_that_includes_rspec_matchers => true
+  end
+
+  describe self do
+    shared_examples_for "a normal module with a method that supers" do
+      it "raises the expected error (and not SystemStackError)" do
+        expect { __method_with_super }.to raise_error(NoMethodError) # there is no __method_with_super in an ancestor
+      end
+    end
+
+    it_behaves_like "a normal module with a method that supers"
+
+    context "when RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when a module that includes RSpec::Matchers has been included in an example group" do
+      include RSpec::Matchers::ModThatIncludesMatchers
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included via configuration", :include_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+
+    context "when RSpec::Matchers is included in a module that is included via configuration", :include_mod_that_includes_rspec_matchers => true do
+      it_behaves_like "a normal module with a method that supers"
+    end
+  end
+end
+

data/spec/rspec/core/runner_spec.rb

@@ -22,24 +22,49 @@ module RSpec::Core
 
     describe "#run" do
       context "with --drb or -X" do
-        before(:each) do
-          @err = @out = StringIO.new
+        let(:err) { StringIO.new }
+        let(: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