rspec-core 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/core/formatters/html_formatter_spec.rb

@@ -6,20 +6,11 @@ require 'nokogiri'
 module RSpec
   module Core
     module Formatters
-      describe HtmlFormatter, :if => RUBY_VERSION =~ /^(1.8.7|1.9.2|1.9.3|2.0.0)$/ do
-        let(:suffix) {
-          if ::RUBY_PLATFORM == 'java'
-            "-jruby"
-          elsif defined?(Rubinius)
-            "-rbx"
-          else
-            ""
-          end
-        }
+      RSpec.describe HtmlFormatter do
 
         let(:root) { File.expand_path("#{File.dirname(__FILE__)}/../../../..") }
         let(:expected_file) do
-          "#{File.dirname(__FILE__)}/html_formatted-#{::RUBY_VERSION}#{suffix}.html"
+          "#{File.dirname(__FILE__)}/html_formatted.html"
         end
 
         let(:generated_html) do
@@ -31,14 +22,28 @@ module RSpec
           command_line = RSpec::Core::CommandLine.new(options)
           command_line.instance_variable_get("@configuration").backtrace_formatter.inclusion_patterns = []
           command_line.run(err, out)
-          out.string.gsub(/\d+\.\d+(s| seconds)/, "n.nnnn\\1")
+          html = out.string.gsub(/\d+\.\d+(s| seconds)/, "n.nnnn\\1")
+
+          actual_doc = Nokogiri::HTML(html)
+          actual_doc.css("div.backtrace pre").each do |elem|
+            # This is to minimize churn on backtrace lines that we do not
+            # assert on anyway.
+            backtrace = elem.inner_html.lines.
+              select {|e| e =~ /formatter_specs\.rb/ }.
+              map {|x| x.chomp.split(":")[0..1].join(':') }.
+              join("\n")
+
+            elem.inner_html = backtrace
+          end
+          actual_doc.inner_html
         end
 
         let(:expected_html) do
-          unless File.file?(expected_file)
-            raise "There is no HTML file with expected content for this platform: #{expected_file}"
+          if File.file?(expected_file)
+            File.read(expected_file)
+          else
+            pending "There is no HTML file with expected content for this platform: #{expected_file}"
           end
-          File.read(expected_file)
         end
 
         before do
@@ -64,7 +69,18 @@ module RSpec
             select  {|e| e =~ /formatter_specs\.rb/}
         end
 
-        describe 'produced HTML' do
+        describe 'produced HTML', :if => RUBY_VERSION <= '2.0.0' do
+          # Rubies before 2 are a wild west of different outputs, and it's not
+          # worth the effort to maintain accurate fixtures for all of them.
+          # Since we are verifying fixtures on other rubies, if this code at
+          # least runs we can be reasonably confident the output is right since
+          # behaviour variances that we care about across versions is neglible.
+          it 'is present' do
+            expect(generated_html).to be
+          end
+        end
+
+        describe 'produced HTML', :slow, :if => RUBY_VERSION >= '2.0.0' do
           def build_and_verify_formatter_output
             Dir.chdir(root) do
               actual_doc = Nokogiri::HTML(generated_html)
@@ -88,15 +104,15 @@ module RSpec
             end
           end
 
-          it "produces HTML identical to the one we designed manually" do
+          it "is identical to the one we designed manually" do
             build_and_verify_formatter_output
           end
 
           context 'with mathn loaded' do
             include MathnIntegrationSupport
 
-            it "produces HTML identical to the one we designed manually" do
-              with_mathn_loaded{ build_and_verify_formatter_output }
+            it "is identical to the one we designed manually", :slow do
+              with_mathn_loaded { build_and_verify_formatter_output }
             end
           end
         end

data/spec/rspec/core/formatters/json_formatter_spec.rb

@@ -11,30 +11,28 @@ require 'rspec/core/reporter'
 # it "shows the pending message if one was given"
 # it "shows the seed if run was randomized"
 # it "lists pending specs that were fixed"
-describe RSpec::Core::Formatters::JsonFormatter do
-  let(:output) { StringIO.new }
-  let(:formatter) { RSpec::Core::Formatters::JsonFormatter.new(output) }
-  let(:config) { RSpec::Core::Configuration.new }
-  let(:reporter) { RSpec::Core::Reporter.new(config, formatter) }
+RSpec.describe RSpec::Core::Formatters::JsonFormatter do
+  include FormatterSupport
 
   it "outputs json (brittle high level functional test)" do
     group = RSpec::Core::ExampleGroup.describe("one apiece") do
       it("succeeds") { expect(1).to eq 1 }
       it("fails") { fail "eek" }
-      it("pends") { pending "world peace" }
+      it("pends") { pending "world peace"; fail "eek" }
     end
     succeeding_line = __LINE__ - 4
     failing_line = __LINE__ - 4
     pending_line = __LINE__ - 4
 
     now = Time.now
-    Time.stub(:now).and_return(now)
+    allow(Time).to receive(:now).and_return(now)
     reporter.report(2) do |r|
       group.run(r)
     end
 
     # grab the actual backtrace -- kind of a cheat
-    failing_backtrace = formatter.output_hash[:examples][1][:exception][:backtrace]
+    examples = formatter.output_hash[:examples]
+    failing_backtrace = examples[1][:exception][:backtrace]
     this_file = relative_path(__FILE__)
 
     expected = {
@@ -45,6 +43,7 @@ describe RSpec::Core::Formatters::JsonFormatter do
           :status => "passed",
           :file_path => this_file,
           :line_number => succeeding_line,
+          :run_time => formatter.output_hash[:examples][0][:run_time]
         },
         {
           :description => "fails",
@@ -52,7 +51,12 @@ describe RSpec::Core::Formatters::JsonFormatter do
           :status => "failed",
           :file_path => this_file,
           :line_number => failing_line,
-          :exception => {:class => "RuntimeError", :message => "eek", :backtrace => failing_backtrace}
+          :run_time => formatter.output_hash[:examples][1][:run_time],
+          :exception => {
+            :class     => "RuntimeError",
+            :message   => "eek",
+            :backtrace => failing_backtrace
+          }
         },
         {
           :description => "pends",
@@ -60,6 +64,7 @@ describe RSpec::Core::Formatters::JsonFormatter do
           :status => "pending",
           :file_path => this_file,
           :line_number => pending_line,
+          :run_time => formatter.output_hash[:examples][2][:run_time]
         },
       ],
       :summary => {
@@ -76,7 +81,7 @@ describe RSpec::Core::Formatters::JsonFormatter do
 
   describe "#stop" do
     it "adds all examples to the output hash" do
-      formatter.stop
+      send_notification :stop, null_notification
       expect(formatter.output_hash[:examples]).not_to be_nil
     end
   end
@@ -84,43 +89,40 @@ describe RSpec::Core::Formatters::JsonFormatter do
   describe "#close" do
     it "outputs the results as a JSON string" do
       expect(output.string).to eq ""
-      formatter.close
-      expect(output.string).to eq({}.to_json)
+      send_notification :close, null_notification
+      expect(output.string).to eq("{}")
     end
   end
 
   describe "#message" do
     it "adds a message to the messages list" do
-      formatter.message("good job")
+      send_notification :message, message_notification("good job")
       expect(formatter.output_hash[:messages]).to eq ["good job"]
     end
   end
 
   describe "#dump_summary" do
     it "adds summary info to the output hash" do
-      values = { :duration => 1.0, :example_count => 2, :failure_count => 1, :pending_count => 1 }
-      formatter.dump_summary(values[:duration], values[:example_count], values[:failure_count], values[:pending_count])
-      summary = formatter.output_hash[:summary]
-      values.each do |key,value|
-        expect(summary[key]).to eq value
-      end
+      send_notification :dump_summary, summary_notification(1.0, 10, 3, 4)
+      expect(formatter.output_hash[:summary]).to include(
+        :duration => 1.0, :example_count => 10, :failure_count => 3,
+        :pending_count => 4
+      )
       summary_line = formatter.output_hash[:summary_line]
-      expect(summary_line).to eq "2 examples, 1 failure, 1 pending"
+      expect(summary_line).to eq "10 examples, 3 failures, 4 pending"
     end
   end
 
-  describe "#dump_profile_slowest_examples" do
+  describe "#dump_profile_slowest_examples", :slow do
 
     before do
       group = RSpec::Core::ExampleGroup.describe("group") do
-        # Use a sleep so there is some measurable time, to ensure
-        # the reported percent is 100%, not 0%.
-        example("example") { sleep 0.001 }
+        example("example") { }
       end
-      group.run(double('reporter').as_null_object)
+      group.run(reporter)
 
-      formatter.stub(:examples) { group.examples }
-      RSpec.configuration.stub(:profile_examples) { 10 }
+      allow(formatter).to receive(:examples) { group.examples }
+      allow(RSpec.configuration).to receive(:profile_examples) { 10 }
     end
 
     it "names the example" do
@@ -139,23 +141,23 @@ describe RSpec::Core::Formatters::JsonFormatter do
     end
   end
 
-  describe "#dump_profile_slowest_example_groups" do
+  describe "#dump_profile_slowest_example_groups", :slow do
     let(:group) do
       RSpec::Core::ExampleGroup.describe("slow group") do
-        # Use a sleep so there is some measurable time, to ensure
-        # the reported percent is 100%, not 0%.
-        example("example") { sleep 0.01 }
+        example("example") do |example|
+          # make it look slow without actually taking up precious time
+          example.clock = class_double(RSpec::Core::Time, :now => RSpec::Core::Time.now + 0.5)
+        end
       end
     end
-    let(:rpt) { double('reporter').as_null_object }
 
     before do
-      RSpec.configuration.stub(:profile_examples) { 10 }
-      group.run(rpt)
+      allow(RSpec.configuration).to receive(:profile_examples) { 10 }
+      group.run(reporter)
     end
 
     context "with one example group" do
-      before { formatter.stub(:examples) { group.examples } }
+      before { allow(formatter).to receive(:examples) { group.examples } }
 
       it "doesn't profile a single example group" do
         formatter.dump_profile_slowest_example_groups
@@ -163,15 +165,15 @@ describe RSpec::Core::Formatters::JsonFormatter do
       end
     end
 
-    context "with multiple example groups" do
+    context "with multiple example groups", :slow do
       before do
         group2 = RSpec::Core::ExampleGroup.describe("fast group") do
-          example("example 1") { sleep 0.004 }
-          example("example 2") { sleep 0.007 }
+          example("example 1") { }
+          example("example 2") { }
         end
-        group2.run(rpt)
+        group2.run(reporter)
 
-        formatter.stub(:examples) { group.examples + group2.examples }
+        allow(formatter).to receive(:examples) { group.examples + group2.examples }
       end
 
       it "provides the slowest example groups" do

data/spec/rspec/core/formatters/legacy_formatter_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'rspec/core/formatters/legacy_formatter'
+require 'support/old_style_formatter_example'
+require 'support/legacy_formatter_using_sub_classing_example'
+
+RSpec.describe RSpec::Core::Formatters::LegacyFormatter do
+  include FormatterSupport
+
+  it 'can access attributes provided by base class accessors in #initialize' do
+    klass = Class.new(LegacyFormatterUsingSubClassing) do
+      def initialize(*args)
+        example_count
+        super
+      end
+    end
+
+    config.add_formatter klass
+    expect(config.formatters.first).to be_a(RSpec::Core::Formatters::LegacyFormatter)
+    expect(config.formatters.first.formatter).to be_a(klass)
+  end
+
+  [OldStyleFormatterExample, LegacyFormatterUsingSubClassing].each do |klass|
+
+    describe "#{klass}" do
+      let(:described_class) { klass }
+
+      describe "#start" do
+        it "notifies formatter of start" do
+          send_notification :start, count_notification(5)
+          expect(output.string).to include "Started 5 examples"
+        end
+      end
+
+      describe "#example_group_started" do
+        it "notifies formatter of example_group_started" do
+          send_notification :example_group_started, group_notification
+          expect(output.string).to include "Started Group"
+        end
+      end
+
+      describe "#example_group_finished" do
+        it "notifies formatter of example_group_finished" do
+          send_notification :example_group_finished, group_notification
+          expect(output.string).to include "Finished Group"
+        end
+      end
+
+      describe "#example_started" do
+        it "notifies formatter of example_started" do
+          send_notification :example_started, example_notification
+          expect(output.string).to include "Started Example"
+        end
+      end
+
+      describe "#example_passed" do
+        it "notifies formatter of example_passed" do
+          send_notification :example_passed, example_notification
+          expect(output.string).to include "."
+        end
+      end
+
+      describe "#example_pending" do
+        it "notifies formatter of example_pending" do
+          send_notification :example_pending, example_notification
+          expect(output.string).to include "P"
+        end
+      end
+
+      describe "#example_failed" do
+        it "notifies formatter of example_failed" do
+          send_notification :example_failed, example_notification
+          expect(output.string).to include "F"
+        end
+      end
+
+      describe "#message" do
+        it "notifies formatter of message" do
+          send_notification :message, message_notification("A Message")
+          expect(output.string).to include "A Message"
+        end
+      end
+
+      describe "#stop" do
+        it "notifies formatter of stop" do
+          send_notification :stop, null_notification
+          expect(output.string).to include "Stopped"
+        end
+      end
+
+      describe "#start_dump" do
+        it "notifies formatter of start_dump" do
+          send_notification :start_dump, null_notification
+          expect(output.string).to include "Dumping!"
+        end
+      end
+
+      describe "#dump_failures" do
+        it "notifies formatter of dump_failures" do
+          send_notification :dump_failures, null_notification
+          expect(output.string).to include "Failures:"
+        end
+      end
+
+      describe "#dump_summary" do
+        it "notifies formatter of dump_summary" do
+          duration, count, failures, pending = 3.5, 10, 3, 2
+          send_notification :dump_summary, summary_notification(duration, count, failures, pending)
+          expect(output.string).to(
+                match("Finished in 3.5").
+            and match("3/10 failed.").
+            and match("2 pending.")
+          )
+        end
+      end
+
+      describe "#dump_pending" do
+        it "notifies formatter of dump_pending" do
+          send_notification :dump_pending, null_notification
+          expect(output.string).to match "Pending:"
+        end
+      end
+
+      describe "#seed" do
+        it "notifies formatter of seed" do
+          send_notification :seed, seed_notification(17)
+          expect(output.string).to match "Randomized with seed 17"
+        end
+      end
+
+      describe "#close" do
+        it "notifies formatter of close" do
+          send_notification :close, null_notification
+        end
+      end
+    end
+  end
+end

data/spec/rspec/core/formatters/progress_formatter_spec.rb

@@ -1,30 +1,43 @@
 require 'spec_helper'
 require 'rspec/core/formatters/progress_formatter'
 
-describe RSpec::Core::Formatters::ProgressFormatter do
-
-   before do
-     @output = StringIO.new
-     @formatter = RSpec::Core::Formatters::ProgressFormatter.new(@output)
-     @formatter.start(2)
-     @formatter.stub(:color_enabled?).and_return(false)
-   end
-
-   it "produces line break on start dump" do
-     @formatter.start_dump
-     expect(@output.string).to eq("\n")
-   end
-
-   it "produces standard summary without pending when pending has a 0 count" do
-     @formatter.start_dump
-     @formatter.dump_summary(0.00001, 2, 0, 0)
-     expect(@output.string).to match(/2 examples, 0 failures/i)
-     expect(@output.string).not_to match(/0 pending/i)
-   end
-
-   it "pushes nothing on start" do
-     @formatter.start(4)
-     expect(@output.string).to eq("")
-   end
+RSpec.describe RSpec::Core::Formatters::ProgressFormatter do
+  include FormatterSupport
 
+  before do
+    send_notification :start, count_notification(2)
+    allow(formatter).to receive(:color_enabled?).and_return(false)
+  end
+
+  it 'prints a . on example_passed' do
+    send_notification :example_passed, example_notification
+    expect(output.string).to eq(".")
+  end
+
+  it 'prints a * on example_pending' do
+    send_notification :example_pending, example_notification
+    expect(output.string).to eq("*")
+  end
+
+  it 'prints a F on example_failed' do
+    send_notification :example_failed, example_notification
+    expect(output.string).to eq("F")
+  end
+
+  it "produces standard summary without pending when pending has a 0 count" do
+    send_notification :dump_summary, summary_notification(0.00001, 2, 0, 0)
+    expect(output.string).to match(/^\n/)
+    expect(output.string).to match(/2 examples, 0 failures/i)
+    expect(output.string).not_to match(/0 pending/i)
+  end
+
+  it "pushes nothing on start" do
+    #start already sent
+    expect(output.string).to eq("")
+  end
+
+  it "pushes nothing on start dump" do
+    send_notification :start_dump, null_notification
+    expect(output.string).to eq("\n")
+  end
 end