rspec-core 2.6.0 → 2.7.0.rc1

data/spec/rspec/core/metadata_spec.rb

@@ -17,67 +17,120 @@ module RSpec
         it "uses :caller if passed as part of the user metadata" do
           m = Metadata.new
           m.process('group', :caller => ['example_file:42'])
-          m[:example_group][:location].should == 'example_file:42'
+          m[:example_group][:location].should eq("example_file:42")
         end
       end
 
-      describe "#apply_condition" do
+      describe "#filter_applies?" do
 
         let(:parent_group_metadata) { Metadata.new.process('parent group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
-        let(:parent_group_line_number) { parent_group_metadata[:example_group][:line_number] }
         let(:group_metadata) { Metadata.new(parent_group_metadata).process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
-        let(:group_line_number) { group_metadata[:example_group][:line_number] }
         let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"], :if => true) }
-        let(:example_line_number) { example_metadata[:line_number] }
         let(:next_example_metadata) { group_metadata.for_example('next_example', :caller => ["foo_spec.rb:#{example_line_number + 2}"]) }
         let(:world) { World.new }
 
         before { RSpec.stub(:world) { world } }
 
-        it "matches the group when the line_number is the example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(group_line_number)
-          # this call doesn't really make sense since apply_condition is only called
-          # for example metadata not group metadata
-          group_metadata.apply_condition(:line_number, group_line_number).should be_true
-        end
+        shared_examples_for "matching by line number" do
+          let(:preceeding_declaration_lines) {{
+            parent_group_metadata[:example_group][:line_number] => parent_group_metadata[:example_group][:line_number],
+            group_metadata[:example_group][:line_number] => group_metadata[:example_group][:line_number],
+            example_metadata[:line_number] => example_metadata[:line_number],
+            (example_metadata[:line_number] + 1) => example_metadata[:line_number],
+            (example_metadata[:line_number] + 2) => example_metadata[:line_number] + 2,
+          }}
+          before do
+            world.should_receive(:preceding_declaration_line).at_least(:once).and_return do |v|
+              preceeding_declaration_lines[v]
+            end
+          end
 
-        it "matches the example when the line_number is the grandparent example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(parent_group_line_number)
-          example_metadata.apply_condition(:line_number, parent_group_line_number).should be_true
-        end
+          it "matches the group when the line_number is the example group line number" do
+            # this call doesn't really make sense since filter_applies? is only called
+            # for example metadata not group metadata
+            group_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the grandparent example group line number" do
+            example_metadata.filter_applies?(condition_key, parent_group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the parent example group line number" do
+            example_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the example line number" do
+            example_metadata.filter_applies?(condition_key, example_condition).should be_true
+          end
 
-        it "matches the example when the line_number is the parent example group line number" do
-          world.should_receive(:preceding_declaration_line).and_return(group_line_number)
-          example_metadata.apply_condition(:line_number, group_line_number).should be_true
+          it "matches when the line number is between this example and the next" do
+            example_metadata.filter_applies?(condition_key, between_examples_condition).should be_true
+          end
+
+          it "does not match when the line number matches the next example" do
+            example_metadata.filter_applies?(condition_key, next_example_condition).should be_false
+          end
         end
 
-        it "matches the example when the line_number is the example line number" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number)
-          example_metadata.apply_condition(:line_number, example_line_number).should be_true
+        context "with a single line number" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [example_metadata[:line_number]] }
+          let(:between_examples_condition) { [group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
         end
 
-        it "matches when the line number is between this example and the next" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number)
-          example_metadata.apply_condition(:line_number, example_line_number + 1).should be_true
+        context "with multiple line numbers" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [-1, parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [-1, group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [-1, example_metadata[:line_number]] }
+          let(:between_examples_condition) { [-1, group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [-1, example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
         end
 
-        it "does not match when the line number matches the next example" do
-          world.should_receive(:preceding_declaration_line).and_return(example_line_number + 2)
-          example_metadata.apply_condition(:line_number, example_line_number + 2).should be_false
+        context "with locations" do
+          let(:condition_key){ :locations }
+          let(:parent_group_condition) do
+            {File.expand_path(parent_group_metadata[:example_group][:file_path]) => [parent_group_metadata[:example_group][:line_number]]}
+          end
+          let(:group_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number]]}
+          end
+          let(:example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number]]}
+          end
+          let(:between_examples_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number] + 1]}
+          end
+          let(:next_example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number] + 2]}
+          end
+
+          it_has_behavior "matching by line number"
+
+          it "ignores location filters for other files" do
+            example_metadata.filter_applies?(:locations, {"/path/to/other_spec.rb" => [3,5,7]}).should be_true
+          end
         end
 
         it "matches a proc that evaluates to true" do
-          example_metadata.apply_condition(:if, lambda { |v| v }).should be_true
+          example_metadata.filter_applies?(:if, lambda { |v| v }).should be_true
         end
 
         it "does not match a proc that evaluates to false" do
-          example_metadata.apply_condition(:if, lambda { |v| !v }).should be_false
+          example_metadata.filter_applies?(:if, lambda { |v| !v }).should be_false
         end
 
         it "passes the metadata hash as the second argument if a given proc expects 2 args" do
           passed_metadata = nil
-          example_metadata.apply_condition(:if, lambda { |v, m| passed_metadata = m })
-          passed_metadata.should == example_metadata
+          example_metadata.filter_applies?(:if, lambda { |v, m| passed_metadata = m })
+          passed_metadata.should eq(example_metadata)
         end
       end
 
@@ -87,43 +140,43 @@ module RSpec
         let(:line_number)        { __LINE__ - 1 }
 
         it "stores the description" do
-          mfe[:description].should == "example description"
+          mfe[:description].should eq("example description")
         end
 
         it "stores the full_description (group description + example description)" do
-          mfe[:full_description].should == "group description example description"
+          mfe[:full_description].should eq("group description example description")
         end
 
         it "creates an empty execution result" do
-          mfe[:execution_result].should == {}
+          mfe[:execution_result].should eq({})
         end
 
         it "extracts file path from caller" do
-          mfe[:file_path].should == __FILE__
+          mfe[:file_path].should eq(__FILE__)
         end
 
         it "extracts line number from caller" do
-          mfe[:line_number].should == line_number
+          mfe[:line_number].should eq(line_number)
         end
 
         it "extracts location from caller" do
-          mfe[:location].should == "#{__FILE__}:#{line_number}"
+          mfe[:location].should eq("#{__FILE__}:#{line_number}")
         end
 
         it "uses :caller if passed as an option" do
           example_metadata = metadata.for_example('example description', {:caller => ['example_file:42']})
-          example_metadata[:location].should == 'example_file:42'
+          example_metadata[:location].should eq("example_file:42")
         end
 
         it "merges arbitrary options" do
-          mfe[:arbitrary].should == :options
+          mfe[:arbitrary].should eq(:options)
         end
 
         it "points :example_group to the same hash object" do
           a = metadata.for_example("foo", {})[:example_group]
           b = metadata.for_example("bar", {})[:example_group]
           a[:description] = "new description"
-          b[:description].should == "new description"
+          b[:description].should eq("new description")
         end
       end
 
@@ -133,7 +186,6 @@ module RSpec
             m = Metadata.new
             m.process('group')
 
-            m = m.for_example("example", {})
             m[:example_group][:describes].should be_nil
           end
         end
@@ -143,7 +195,6 @@ module RSpec
             m = Metadata.new
             m.process(:group)
 
-            m = m.for_example("example", {})
             m[:example_group][:describes].should be_nil
           end
         end
@@ -153,49 +204,73 @@ module RSpec
             m = Metadata.new
             m.process(String)
 
-            m = m.for_example("example", {})
             m[:example_group][:describes].should be(String)
           end
         end
 
-        context "with describes from a superclass metadata" do
-          it "returns the superclass' described class" do
+        context "in a nested group" do
+          it "returns the parent group's described class" do
             sm = Metadata.new
             sm.process(String)
 
             m = Metadata.new(sm)
             m.process(Array)
 
-            m = m.for_example("example", {})
             m[:example_group][:describes].should be(String)
           end
+
+          it "returns own described class if parent doesn't have one" do
+            sm = Metadata.new
+            sm.process("foo")
+
+            m = Metadata.new(sm)
+            m.process(Array)
+
+            m[:example_group][:describes].should be(Array)
+          end
+
+          it "can override a parent group's described class" do
+            parent = Metadata.new
+            parent.process(String)
+
+            child = Metadata.new(parent)
+            child.process(Fixnum)
+            child[:example_group][:describes] = Hash
+
+            grandchild = Metadata.new(child)
+            grandchild.process(Array)
+
+            grandchild[:example_group][:describes].should be(Hash)
+            child[:example_group][:describes].should be(Hash)
+            parent[:example_group][:describes].should be(String)
+          end
         end
       end
 
       describe ":description" do
         it "just has the example description" do
           m = Metadata.new
-          m.process('group')
+          m.process("group")
 
           m = m.for_example("example", {})
-          m[:description].should == "example"
+          m[:description].should eq("example")
         end
 
         context "with a string" do
           it "provides the submitted description" do
             m = Metadata.new
-            m.process('group')
+            m.process("group")
 
-            m[:example_group][:description].should == "group"
+            m[:example_group][:description].should eq("group")
           end
         end
 
         context "with a non-string" do
           it "provides the submitted description" do
             m = Metadata.new
-            m.process('group')
+            m.process("group")
 
-            m[:example_group][:description].should == "group"
+            m[:example_group][:description].should eq("group")
           end
         end
 
@@ -204,7 +279,16 @@ module RSpec
             m = Metadata.new
             m.process(Object, 'group')
 
-            m[:example_group][:description].should == "Object group"
+            m[:example_group][:description].should eq("Object group")
+          end
+        end
+
+        context "with empty args" do
+          it "returns empty string for [:example_group][:description]" do
+            m = Metadata.new
+            m.process()
+
+            m[:example_group][:description].should eq("")
           end
         end
       end
@@ -215,17 +299,18 @@ module RSpec
           group_metadata.process('group')
 
           example_metadata = group_metadata.for_example("example", {})
-          example_metadata[:full_description].should == "group example"
+          example_metadata[:full_description].should eq("group example")
         end
 
         it "concats nested example group descriptions" do
           parent = Metadata.new
-          parent.process(Object, 'parent')
+          parent.process('parent')
 
           child = Metadata.new(parent)
           child.process('child')
 
-          child[:example_group][:full_description].should == "Object parent child"
+          child[:example_group][:full_description].should eq("parent child")
+          child.for_example('example', child)[:full_description].should eq("parent child example")
         end
 
         %w[# . ::].each do |char|
@@ -258,7 +343,7 @@ module RSpec
                     "./lib/rspec/core/foo.rb",
                     "#{__FILE__}:#{__LINE__}"
           ])
-          m[:example_group][:file_path].should == __FILE__
+          m[:example_group][:file_path].should eq(__FILE__)
         end
       end
 
@@ -266,19 +351,19 @@ module RSpec
         it "finds the line number with the first non-rspec lib file in the backtrace" do
           m = Metadata.new
           m.process({})
-          m[:example_group][:line_number].should == __LINE__ - 1
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
         end
 
         it "finds the line number with the first spec file with drive letter" do
           m = Metadata.new
           m.process(:caller => [ "C:/path/to/file_spec.rb:#{__LINE__}" ])
-          m[:example_group][:line_number].should == __LINE__ - 1
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
         end
 
         it "uses the number after the first : for ruby 1.9" do
           m = Metadata.new
           m.process(:caller => [ "#{__FILE__}:#{__LINE__}:999" ])
-          m[:example_group][:line_number].should == __LINE__ - 1
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
         end
       end
 
@@ -290,7 +375,7 @@ module RSpec
           child = Metadata.new(parent)
           child.process()
 
-          child[:example_group][:example_group].should == parent[:example_group]
+          child[:example_group][:example_group].should eq(parent[:example_group])
         end
       end
     end

data/spec/rspec/core/pending_example_spec.rb

@@ -30,10 +30,10 @@ describe "an example" do
       it "does not have an auto-generated description" do
         group = RSpec::Core::ExampleGroup.describe('group') do
           it "checks something" do
-            (3+4).should == 7
+            (3+4).should eq(7)
           end
           pending do
-            "string".reverse.should == "gnirts"
+            "string".reverse.should eq("gnirts")
           end
         end
         example = group.examples.last
@@ -45,7 +45,7 @@ describe "an example" do
       it "does not show any message" do
         group = RSpec::Core::ExampleGroup.describe('group') do
           it "checks something" do
-            (3+4).should == 7
+            (3+4).should eq(7)
           end
           specify do
             pending
@@ -145,7 +145,7 @@ describe "an example" do
 
     context "that passes" do
       def run_example(*pending_args)
-        super(*pending_args) { 3.should == 3 }
+        super(*pending_args) { 3.should eq(3) }
       end
 
       context "when given no options" do

data/spec/rspec/core/rake_task_spec.rb

@@ -1,18 +1,29 @@
 require "spec_helper"
 require "rspec/core/rake_task"
+require 'tempfile'
 
 module RSpec::Core
   describe RakeTask do
     let(:task) { RakeTask.new }
 
-    before do
-      File.stub(:exist?) { false }
+    def ruby
+      FileUtils::RUBY
     end
 
-    def with_bundler
-      task.skip_bundler = false
-      File.stub(:exist?) { true }
-      yield
+    def with_bundle_gemfile(val)
+      begin
+        orig = ENV['BUNDLE_GEMFILE']
+        ENV['BUNDLE_GEMFILE'] = val
+        yield
+      ensure
+        ENV['BUNDLE_GEMFILE'] = orig
+      end
+    end
+
+    def without_bundler
+      with_bundle_gemfile nil do
+        yield
+      end
     end
 
     def with_rcov
@@ -24,52 +35,41 @@ module RSpec::Core
       task.__send__(:spec_command)
     end
 
-    context "default" do
+    context "default (BUNDLE_GEMFILE nil)" do
       it "renders rspec" do
-        spec_command.should =~ /^-S rspec/
-      end
-    end
-
-    context "with bundler" do
-      context "with Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) { true }
-          task.skip_bundler = false
-          spec_command.should match(/bundle exec/)
+        with_bundle_gemfile nil do
+          spec_command.should =~ /^#{ruby} -S rspec/
         end
       end
+    end
 
-      context "with non-standard Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) {|f| f =~ /AltGemfile/}
-          task.gemfile = 'AltGemfile'
-          task.skip_bundler = false
-          spec_command.should match(/bundle exec/)
+    context "default (BUNDLE_GEMFILE '')" do
+      it "renders rspec" do
+        with_bundle_gemfile '' do
+          spec_command.should =~ /^#{ruby} -S rspec/
         end
       end
+    end
 
-      context "without Gemfile" do
-        it "renders bundle exec rspec" do
-          File.stub(:exist?) { false }
-          task.skip_bundler = false
-          spec_command.should_not match(/bundle exec/)
-        end
+    context "with bundler (BUNDLE_GEMFILE non-blank)" do
+      it "renders bundle exec rspec" do
+        spec_command.should match(/bundle exec/)
       end
     end
 
     context "with rcov" do
       it "renders rcov" do
-        with_rcov do
-          spec_command.should =~ /^-S rcov/
+        without_bundler do
+          with_rcov do
+            spec_command.should =~ /^#{ruby} -S rcov/
+          end
         end
       end
-    end
 
-    context "with bundler and rcov" do
-      it "renders bundle exec rcov" do
-        with_bundler do
+      context "with bundler" do
+        it "renders bundle exec rcov" do
           with_rcov do
-            spec_command.should =~ /^-S bundle exec rcov/
+            spec_command.should =~ /^bundle exec #{ruby} -S rcov/
           end
         end
       end
@@ -77,8 +77,10 @@ module RSpec::Core
 
     context "with ruby options" do
       it "renders them before -S" do
-        task.ruby_opts = "-w"
-        spec_command.should =~ /^-w -S rspec/
+        without_bundler do
+          task.ruby_opts = "-w"
+          spec_command.should =~ /^#{ruby} -w -S rspec/
+        end
       end
     end
 
@@ -138,23 +140,42 @@ module RSpec::Core
     end
 
     context "with paths with quotes" do
-      before do
-        @tmp_dir = File.expand_path('./tmp/rake_task_example/')
-        FileUtils.mkdir_p @tmp_dir
-        @task = RakeTask.new do |t|
-          t.pattern = File.join(@tmp_dir, "*spec.rb")
+      it "escapes the quotes" do
+        task = RakeTask.new do |t|
+          t.pattern = File.join(Dir.tmpdir, "*spec.rb")
         end
         ["first_spec.rb", "second_\"spec.rb", "third_\'spec.rb"].each do |file_name|
-          FileUtils.touch(File.join(@tmp_dir, file_name))
+          FileUtils.touch(File.join(Dir.tmpdir, file_name))
         end
+        task.__send__(:files_to_run).sort.should eq([
+          File.join(Dir.tmpdir, "first_spec.rb"),
+          File.join(Dir.tmpdir, "second_\\\"spec.rb"),
+          File.join(Dir.tmpdir, "third_\\\'spec.rb")
+        ])
       end
+    end
 
-      it "escapes the quotes" do
-        @task.__send__(:files_to_run).sort.should eq([
-          File.join(@tmp_dir, "first_spec.rb"),
-          File.join(@tmp_dir, "second_\\\"spec.rb"),
-          File.join(@tmp_dir, "third_\\\'spec.rb") 
-        ])
+    context "with paths including symlinked directories" do
+      it "finds the files" do
+        project_dir = File.join(Dir.tmpdir, "project")
+        FileUtils.rm_rf project_dir
+
+        foos_dir = File.join(project_dir, "spec/foos")
+        FileUtils.mkdir_p foos_dir
+        FileUtils.touch(File.join(foos_dir, "foo_spec.rb"))
+
+        bars_dir = File.join(Dir.tmpdir, "shared/spec/bars")
+        FileUtils.mkdir_p bars_dir
+        FileUtils.touch(File.join(bars_dir, "bar_spec.rb"))
+
+        FileUtils.ln_s bars_dir, File.join(project_dir, "spec/bars")
+
+        FileUtils.cd(project_dir) do
+          RakeTask.new.__send__(:files_to_run).sort.should eq([
+            "./spec/bars/bar_spec.rb",
+            "./spec/foos/foo_spec.rb"
+          ])
+        end
       end
     end
   end

data/spec/rspec/core/reporter_spec.rb

@@ -44,14 +44,14 @@ module RSpec::Core
 
         group.run(Reporter.new(formatter))
 
-        order.should == [
+        order.should eq([
            "Started: root",
            "Started: context 1",
            "Finished: context 1",
            "Started: context 2",
            "Finished: context 2",
            "Finished: root"
-        ]
+        ])
       end
     end
 

data/spec/rspec/core/ruby_project_spec.rb

@@ -7,14 +7,14 @@ module RSpec
         context "with ancestor containing spec directory" do
           it "returns ancestor containing the spec directory" do
             RubyProject.stub(:ascend_until).and_return('foodir')
-            RubyProject.determine_root.should == 'foodir'
+            RubyProject.determine_root.should eq("foodir")
           end
         end
 
         context "without ancestor containing spec directory" do
           it "returns current working directory" do
             RubyProject.stub(:find_first_parent_containing).and_return(nil)
-            RubyProject.determine_root.should == '.'
+            RubyProject.determine_root.should eq(".")
           end
         end
 

data/spec/rspec/core/runner_spec.rb

@@ -7,6 +7,7 @@ module RSpec::Core
         RSpec::Core::Runner.stub(:installed_at_exit?).and_return(false)
         RSpec::Core::Runner.stub(:running_in_drb?).and_return(false)
         RSpec::Core::Runner.stub(:at_exit_hook_disabled?).and_return(false)
+        RSpec::Core::Runner.stub(:run).and_return(-1)
         RSpec::Core::Runner.should_receive(:at_exit)
         RSpec::Core::Runner.autorun
       end
@@ -25,6 +26,7 @@ module RSpec::Core
       let(:out) { StringIO.new }
 
       it "resets world and configuration" do
+        RSpec.configuration.stub(:files_to_run) { [] }
         RSpec.configuration.should_receive(:reset)
         RSpec.world.should_receive(:reset)
         RSpec::Core::Runner.run([], err, out)
@@ -58,6 +60,7 @@ module RSpec::Core
           end
 
           it "outputs a message" do
+            RSpec.configuration.stub(:files_to_run) { [] }
             err.should_receive(:puts).with(
               "No DRb server is running. Running in local process instead ..."
             )
@@ -65,7 +68,7 @@ module RSpec::Core
           end
 
           it "builds a CommandLine and runs the specs" do
-            process_proxy = double(RSpec::Core::CommandLine, :run => true)
+            process_proxy = double(RSpec::Core::CommandLine, :run => 0)
             process_proxy.should_receive(:run).with(err, out)
 
             RSpec::Core::CommandLine.should_receive(:new).and_return(process_proxy)