rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/core/ordering_spec.rb

@@ -3,13 +3,13 @@ require "spec_helper"
 module RSpec
   module Core
     module Ordering
-      describe Identity do
+      RSpec.describe Identity do
         it "does not affect the ordering of the items" do
           expect(Identity.new.order([1, 2, 3])).to eq([1, 2, 3])
         end
       end
 
-      describe Random do
+      RSpec.describe Random do
         describe '.order' do
           subject { described_class.new(configuration) }
 
@@ -48,7 +48,7 @@ module RSpec
         end
       end
 
-      describe Custom do
+      RSpec.describe Custom do
         it 'uses the block to order the list' do
           strategy = Custom.new(proc { |list| list.reverse })
 
@@ -56,7 +56,7 @@ module RSpec
         end
       end
 
-      describe Registry do
+      RSpec.describe Registry do
         let(:configuration) { Configuration.new }
         subject(:registry) { Registry.new(configuration) }
 

data/spec/rspec/core/pending_example_spec.rb

@@ -1,20 +1,11 @@
 require 'spec_helper'
 
-describe "an example" do
-  matcher :be_pending_with do |message|
-    match do |example|
-      example.pending? && example.metadata[:execution_result][:pending_message] == message
-    end
-
-    failure_message_for_should do |example|
-      "expected: example pending with #{message.inspect}\n     got: #{example.metadata[:execution_result][:pending_message].inspect}"
-    end
-  end
-
+RSpec.describe "an example" do
   context "declared pending with metadata" do
     it "uses the value assigned to :pending as the message" do
       group = RSpec::Core::ExampleGroup.describe('group') do
         example "example", :pending => 'just because' do
+          fail
         end
       end
       example = group.examples.first
@@ -25,6 +16,7 @@ describe "an example" do
     it "sets the message to 'No reason given' if :pending => true" do
       group = RSpec::Core::ExampleGroup.describe('group') do
         example "example", :pending => true do
+          fail
         end
       end
       example = group.examples.first
@@ -40,7 +32,7 @@ describe "an example" do
       end
       example = group.examples.first
       example.run(group.new, double.as_null_object)
-      expect(example).to be_pending_with('Not yet implemented')
+      expect(example).to be_skipped_with('Not yet implemented')
     end
   end
 
@@ -49,12 +41,30 @@ describe "an example" do
       group = RSpec::Core::ExampleGroup.describe('group') do
         it "does something" do
           pending
+          fail
         end
       end
       example = group.examples.first
       example.run(group.new, double.as_null_object)
       expect(example).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
     end
+
+    it "fails when the rest of the example passes" do
+      called = false
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending
+          called = true
+        end
+      end
+
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(called).to eq(true)
+      result = example.metadata[:execution_result]
+      expect(result[:pending_fixed]).to eq(true)
+      expect(result[:status]).to eq("failed")
+    end
   end
 
   context "with no docstring" do
@@ -96,6 +106,7 @@ describe "an example" do
       group = RSpec::Core::ExampleGroup.describe('group') do
         it "does something" do
           pending("just because")
+          fail
         end
       end
       example = group.examples.first
@@ -103,118 +114,4 @@ describe "an example" do
       expect(example).to be_pending_with('just because')
     end
   end
-
-  context "with a block" do
-    def run_example(*pending_args, &block)
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending(*pending_args) { block.call if block }
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-      example
-    end
-
-    context "that fails" do
-      def run_example(*pending_args)
-        super(*pending_args) { raise ArgumentError.new }
-      end
-
-      context "when given no options" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because")).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because", :if => true)).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example(:if => true)).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and fails" do
-          expect(run_example(                :if => false)).to fail_with(ArgumentError)
-          expect(run_example("just because", :if => false)).to fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and fails" do
-          expect(run_example(                :unless => true)).to fail_with(ArgumentError)
-          expect(run_example("just because", :unless => true)).to fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because", :unless => false)).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example(:unless => false)).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      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
-        expect(run_example("just because")).to be_pending
-      end
-    end
-
-    context "that passes" do
-      def run_example(*pending_args)
-        super(*pending_args) { expect(3).to eq(3) }
-      end
-
-      context "when given no options" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because")).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example).to                 fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because", :if => true)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example(                :if => true)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and it passes" do
-          expect(run_example(                :if => false)).to pass
-          expect(run_example("just because", :if => false)).to pass
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and it passes" do
-          expect(run_example(                :unless => true)).to pass
-          expect(run_example("just because", :unless => true)).to pass
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because", :unless => false)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example(                :unless => false)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-    end
-  end
 end

data/spec/rspec/core/pending_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe RSpec::Core::Pending do
+  it 'only defines methods that are part of the DSL' do
+    expect(RSpec::Core::Pending.instance_methods(false).map(&:to_sym)).to \
+      match_array([:pending, :skip])
+  end
+end

data/spec/rspec/core/project_initializer_spec.rb

@@ -2,33 +2,33 @@ require "spec_helper"
 require 'rspec/core/project_initializer'
 
 module RSpec::Core
-  describe ProjectInitializer, :isolated_directory => true do
+  RSpec.describe ProjectInitializer, :isolated_directory => true do
 
     describe "#run" do
       context "with no args" do
         let(:command_line_config) { ProjectInitializer.new }
 
         before do
-          command_line_config.stub(:puts)
-          command_line_config.stub(:gets => 'no')
+          allow(command_line_config).to receive(:puts)
+          allow(command_line_config).to receive_messages(:gets => 'no')
         end
 
         context "with no .rspec file" do
           it "says it's creating .rspec " do
-            command_line_config.should_receive(:puts).with(/create\s+\.rspec/)
+            expect(command_line_config).to receive(:puts).with(/create\s+\.rspec/)
             command_line_config.run
           end
 
           it "generates a .rspec" do
             command_line_config.run
-            expect(File.read('.rspec')).to match(/--color\n--format progress/m)
+            expect(File.read('.rspec')).to match(/--color/m)
           end
         end
 
         context "with a .rspec file" do
           it "says .rspec exists" do
             FileUtils.touch('.rspec')
-            command_line_config.should_receive(:puts).with(/exist\s+\.rspec/)
+            expect(command_line_config).to receive(:puts).with(/exist\s+\.rspec/)
             command_line_config.run
           end
 
@@ -41,7 +41,7 @@ module RSpec::Core
 
         context "with no spec/spec_helper.rb file" do
           it "says it's creating spec/spec_helper.rb " do
-            command_line_config.should_receive(:puts).with(/create\s+spec\/spec_helper.rb/)
+            expect(command_line_config).to receive(:puts).with(/create\s+spec\/spec_helper.rb/)
             command_line_config.run
           end
 
@@ -56,7 +56,7 @@ module RSpec::Core
 
           it "says spec/spec_helper.rb exists" do
             FileUtils.touch('spec/spec_helper.rb')
-            command_line_config.should_receive(:puts).with(/exist\s+spec\/spec_helper.rb/)
+            expect(command_line_config).to receive(:puts).with(/exist\s+spec\/spec_helper.rb/)
             command_line_config.run
           end
 
@@ -67,39 +67,6 @@ module RSpec::Core
             expect(File.read('spec/spec_helper.rb')).to eq(random_content)
           end
         end
-
-        context "with lib/tasks/rspec.rake" do
-          before do
-            FileUtils.mkdir_p('lib/tasks')
-            FileUtils.touch 'lib/tasks/rspec.rake'
-          end
-
-          it "asks whether to delete the file" do
-            command_line_config.should_receive(:puts).with(/delete/)
-            command_line_config.run
-          end
-
-          it "removes it if confirmed" do
-            command_line_config.stub(:gets => 'yes')
-            command_line_config.run
-            expect(File.exist?('lib/tasks/rspec.rake')).to be_falsey
-          end
-
-          it "leaves it if not confirmed" do
-            command_line_config.stub(:gets => 'no')
-            command_line_config.run
-            expect(File.exist?('lib/tasks/rspec.rake')).to be_truthy
-          end
-        end
-      end
-
-      context "given an arg" do
-        it "warns if arg received (no longer necessary)" do
-          config = ProjectInitializer.new("another_arg")
-          config.stub(:puts)
-          config.stub(:gets => 'no')
-          config.run
-        end
       end
     end
   end

data/spec/rspec/core/rake_task_spec.rb

@@ -3,7 +3,7 @@ require "rspec/core/rake_task"
 require 'tempfile'
 
 module RSpec::Core
-  describe RakeTask do
+  RSpec.describe RakeTask do
     let(:task) { RakeTask.new }
 
     def ruby
@@ -28,7 +28,7 @@ module RSpec::Core
           expect(args[:files]).to eq "first_spec.rb"
         end
 
-        task.should_receive(:run_task) { true }
+        expect(task).to receive(:run_task) { true }
         expect(Rake.application.invoke_task("rake_task_args[first_spec.rb]")).to be_truthy
       end
     end
@@ -53,13 +53,24 @@ module RSpec::Core
       end
     end
 
+    context 'with custom exit status' do
+      it 'returns the correct status on exit', :slow do
+        with_isolated_stderr do
+          expect($stderr).to receive(:puts) { |cmd| expect(cmd).to match(/-e "exit\(2\);".* failed/) }
+          expect(task).to receive(:exit).with(2)
+          task.ruby_opts = '-e "exit(2);" ;#'
+          task.run_task false
+        end
+      end
+    end
+
     def specify_consistent_ordering_of_files_to_run(pattern, task)
       orderings = [
         %w[ a/1.rb a/2.rb a/3.rb ],
         %w[ a/2.rb a/1.rb a/3.rb ],
         %w[ a/3.rb a/2.rb a/1.rb ]
       ].map do |files|
-        FileList.should_receive(:[]).with(pattern) { files }
+        expect(FileList).to receive(:[]).with(pattern) { files }
         task.__send__(:files_to_run)
       end
 
@@ -87,7 +98,7 @@ module RSpec::Core
 
       # since the config block is deferred til task invocation, must fake
       # calling the task so the expected pattern is picked up
-      task.should_receive(:run_task) { true }
+      expect(task).to receive(:run_task) { true }
       expect(Rake.application.invoke_task(task.name)).to be_truthy
 
       specify_consistent_ordering_of_files_to_run('a/*.rb', task)

data/spec/rspec/core/random_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module RSpec
   module Core
-    describe RandomNumberGenerator do
+    RSpec.describe RandomNumberGenerator do
       it 'is a random number generator' do
         random = described_class.new
 

data/spec/rspec/core/reporter_spec.rb

@@ -1,26 +1,23 @@
 require "spec_helper"
 
 module RSpec::Core
-  describe Reporter do
-    let(:config) { Configuration.new }
+  RSpec.describe Reporter do
+    let(:config)   { Configuration.new }
+    let(:reporter) { Reporter.new config }
 
-    def reporter_for(*formatters)
-      Reporter.new(config, *formatters)
-    end
-
-    describe "abort" do
+    describe "finish" do
       let(:formatter) { double("formatter") }
       let(:example)   { double("example") }
-      let(:reporter)  { reporter_for(formatter) }
 
-      %w[start_dump dump_pending dump_failures dump_summary close].each do |message|
+      %w[start_dump dump_pending dump_failures dump_summary close].map(&:to_sym).each do |message|
         it "sends #{message} to the formatter(s) that respond to message" do
-          formatter.as_null_object.should_receive(message)
-          reporter.abort
+          reporter.register_listener formatter, message
+          expect(formatter.as_null_object).to receive(message)
+          reporter.finish
         end
 
         it "doesnt notify formatters about messages they dont implement" do
-          expect { reporter.abort }.to_not raise_error
+          expect { reporter.finish }.to_not raise_error
         end
       end
     end
@@ -29,10 +26,11 @@ module RSpec::Core
       it "passes messages to that formatter" do
         formatter = double("formatter", :example_started => nil)
         example = double("example")
-        reporter = reporter_for(formatter)
+        reporter.register_listener formatter, :example_started
 
-        formatter.should_receive(:example_started).
-          with(example)
+        expect(formatter).to receive(:example_started) do |notification|
+          expect(notification.example).to eq example
+        end
 
         reporter.example_started(example)
       end
@@ -40,9 +38,11 @@ module RSpec::Core
       it "passes example_group_started and example_group_finished messages to that formatter in that order" do
         order = []
 
-        formatter = double("formatter").as_null_object
-        formatter.stub(:example_group_started) { |group| order << "Started: #{group.description}" }
-        formatter.stub(:example_group_finished) { |group| order << "Finished: #{group.description}" }
+        formatter = double("formatter")
+        allow(formatter).to receive(:example_group_started)  { |n| order << "Started: #{n.group.description}" }
+        allow(formatter).to receive(:example_group_finished) { |n| order << "Finished: #{n.group.description}" }
+
+        reporter.register_listener formatter, :example_group_started, :example_group_finished
 
         group = ExampleGroup.describe("root")
         group.describe("context 1") do
@@ -52,7 +52,7 @@ module RSpec::Core
           example("ignore") {}
         end
 
-        group.run(reporter_for(formatter))
+        group.run(reporter)
 
         expect(order).to eq([
            "Started: root",
@@ -67,13 +67,15 @@ module RSpec::Core
 
     context "given an example group with no examples" do
       it "does not pass example_group_started or example_group_finished to formatter" do
-        formatter = double("formatter").as_null_object
-        formatter.should_not_receive(:example_group_started)
-        formatter.should_not_receive(:example_group_finished)
+        formatter = double("formatter")
+        expect(formatter).not_to receive(:example_group_started)
+        expect(formatter).not_to receive(:example_group_finished)
+
+        reporter.register_listener formatter, :example_group_started, :example_group_finished
 
         group = ExampleGroup.describe("root")
 
-        group.run(reporter_for(formatter))
+        group.run(reporter)
       end
     end
 
@@ -81,12 +83,12 @@ module RSpec::Core
       it "passes messages to all formatters" do
         formatters = (1..2).map { double("formatter", :example_started => nil) }
         example = double("example")
-        reporter = reporter_for(*formatters)
 
         formatters.each do |formatter|
-          formatter.
-            should_receive(:example_started).
-            with(example)
+          expect(formatter).to receive(:example_started) do |notification|
+            expect(notification.example).to eq example
+          end
+          reporter.register_listener formatter, :example_started
         end
 
         reporter.example_started(example)
@@ -95,19 +97,17 @@ module RSpec::Core
 
     describe "#report" do
       it "supports one arg (count)" do
-        reporter_for.report(1) {}
+        reporter.report(1) {}
       end
 
       it "yields itself" do
-        reporter = reporter_for
         yielded = nil
-        reporter.report(3) {|r| yielded = r}
+        reporter.report(3) { |r| yielded = r }
         expect(yielded).to eq(reporter)
       end
     end
 
     describe "#register_listener" do
-      let(:reporter) { reporter_for }
       let(:listener) { double("listener", :start => nil) }
 
       before { reporter.register_listener listener, :start }
@@ -116,22 +116,35 @@ module RSpec::Core
         expect(reporter.registered_listeners :start).to eq [listener]
       end
 
+      it 'will match string notification names' do
+        reporter.register_listener listener, "stop"
+        expect(reporter.registered_listeners :stop).to eq [listener]
+      end
+
       it 'will send notifications when a subscribed event is triggered' do
-        listener.should_receive(:start).with(42)
+        expect(listener).to receive(:start) do |notification|
+          expect(notification.count).to eq 42
+        end
+        reporter.start 42
+      end
+
+      it 'will ignore duplicated listeners' do
+        reporter.register_listener listener, :start
+        expect(listener).to receive(:start).once
         reporter.start 42
       end
     end
 
     describe "timing" do
       it "uses RSpec::Core::Time as to not be affected by changes to time in examples" do
-        formatter = double(:formatter).as_null_object
-        reporter = reporter_for formatter
+        formatter = double(:formatter)
+        reporter.register_listener formatter, :dump_summary
         reporter.start 1
-        Time.stub(:now => ::Time.utc(2012, 10, 1))
+        allow(Time).to receive_messages(:now => ::Time.utc(2012, 10, 1))
 
         duration = nil
-        formatter.stub(:dump_summary) do |dur, _, _, _|
-          duration = dur
+        allow(formatter).to receive(:dump_summary) do |notification|
+          duration = notification.duration
         end
 
         reporter.finish