opal-rspec 0.4.3 → 0.5.0.beta1

data/rspec-core/spec/rspec/core/formatters/deprecation_formatter_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+require 'rspec/core/reporter'
+require 'rspec/core/formatters/deprecation_formatter'
+require 'tempfile'
+
+module RSpec::Core::Formatters
+  RSpec.describe DeprecationFormatter do
+    include FormatterSupport
+
+    let(:summary_stream) { StringIO.new }
+
+    def notification(hash)
+      ::RSpec::Core::Notifications::DeprecationNotification.from_hash(hash)
+    end
+
+    before do
+      setup_reporter deprecation_stream, summary_stream
+    end
+
+    describe "#deprecation" do
+
+      context "with a File deprecation_stream", :slow do
+        let(:deprecation_stream) { File.open("#{Dir.tmpdir}/deprecation_summary_example_output", "w+") }
+
+        it "prints a message if provided, ignoring other data" do
+          send_notification :deprecation, notification(:message => "this message", :deprecated => "x", :replacement => "y", :call_site => "z")
+          deprecation_stream.rewind
+          expect(deprecation_stream.read).to eq "this message\n"
+        end
+
+        it "surrounds multiline messages in fenceposts" do
+          multiline_message = <<-EOS.gsub(/^\s+\|/, '')
+            |line one
+            |line two
+          EOS
+          send_notification :deprecation, notification(:message => multiline_message)
+          deprecation_stream.rewind
+
+          expected = <<-EOS.gsub(/^\s+\|/, '')
+            |--------------------------------------------------------------------------------
+            |line one
+            |line two
+            |--------------------------------------------------------------------------------
+          EOS
+          expect(deprecation_stream.read).to eq expected
+        end
+
+        it "includes the method" do
+          send_notification :deprecation, notification(:deprecated => "i_am_deprecated")
+          deprecation_stream.rewind
+          expect(deprecation_stream.read).to match(/i_am_deprecated is deprecated/)
+        end
+
+        it "includes the replacement" do
+          send_notification :deprecation, notification(:replacement => "use_me")
+          deprecation_stream.rewind
+          expect(deprecation_stream.read).to match(/Use use_me instead/)
+        end
+
+        it "includes the call site if provided" do
+          send_notification :deprecation, notification(:call_site => "somewhere")
+          deprecation_stream.rewind
+          expect(deprecation_stream.read).to match(/Called from somewhere/)
+        end
+      end
+
+      context "with an IO deprecation stream" do
+        let(:deprecation_stream) { StringIO.new }
+
+        it "prints nothing" do
+          5.times { send_notification :deprecation, notification(:deprecated => 'i_am_deprecated') }
+          expect(deprecation_stream.string).to eq ""
+        end
+      end
+    end
+
+    describe "#deprecation_summary" do
+      let(:summary)   { double }
+
+      context "with a File deprecation_stream", :slow do
+        let(:deprecation_stream) { File.open("#{Dir.tmpdir}/deprecation_summary_example_output", "w") }
+
+        it "prints a count of the deprecations" do
+          send_notification :deprecation, notification(:deprecated => 'i_am_deprecated')
+          send_notification :deprecation_summary, null_notification
+          expect(summary_stream.string).to match(/1 deprecation logged to .*deprecation_summary_example_output/)
+        end
+
+        it "pluralizes the reported deprecation count for more than one deprecation" do
+          send_notification :deprecation, notification(:deprecated => 'i_am_deprecated')
+          send_notification :deprecation, notification(:deprecated => 'i_am_deprecated_also')
+          send_notification :deprecation_summary, null_notification
+          expect(summary_stream.string).to match(/2 deprecations/)
+        end
+
+        it "is not printed when there are no deprecations" do
+          send_notification :deprecation_summary, null_notification
+          expect(summary_stream.string).to eq ""
+        end
+
+        it 'uses synchronized/non-buffered output to work around odd duplicate output behavior we have observed' do
+          expect {
+            send_notification :deprecation, notification(:deprecated => 'foo')
+          }.to change { deprecation_stream.sync }.from(false).to(true)
+        end
+
+        it 'does not print duplicate messages' do
+          3.times { send_notification :deprecation, notification(:deprecated => 'foo') }
+          send_notification :deprecation_summary, null_notification
+
+          expect(summary_stream.string).to match(/1 deprecation/)
+          expect(File.read(deprecation_stream.path)).to eq("foo is deprecated.\n#{DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE}")
+        end
+      end
+
+      context "with an Error deprecation_stream" do
+        let(:deprecation_stream) { DeprecationFormatter::RaiseErrorStream.new }
+
+        it 'prints a summary of the number of deprecations found' do
+          expect { send_notification :deprecation, notification(:deprecated => 'foo') }.to raise_error(RSpec::Core::DeprecationError)
+          send_notification :deprecation_summary, null_notification
+
+          expect(summary_stream.string).to eq("\n1 deprecation found.\n")
+        end
+
+        it 'pluralizes the count when it is greater than 1' do
+          expect { send_notification :deprecation, notification(:deprecated => 'foo') }.to raise_error(RSpec::Core::DeprecationError)
+          expect { send_notification :deprecation, notification(:deprecated => 'bar') }.to raise_error(RSpec::Core::DeprecationError)
+
+          send_notification :deprecation_summary, null_notification
+
+          expect(summary_stream.string).to eq("\n2 deprecations found.\n")
+        end
+      end
+
+      context "with an IO deprecation_stream" do
+        let(:deprecation_stream) { StringIO.new }
+
+        it "groups similar deprecations together" do
+          send_notification :deprecation, notification(:deprecated => 'i_am_deprecated', :call_site => "foo.rb:1")
+          send_notification :deprecation, notification(:deprecated => 'i_am_a_different_deprecation')
+          send_notification :deprecation, notification(:deprecated => 'i_am_deprecated', :call_site => "foo.rb:2")
+          send_notification :deprecation_summary, null_notification
+
+          expected = <<-EOS.gsub(/^\s+\|/, '')
+            |
+            |Deprecation Warnings:
+            |
+            |i_am_a_different_deprecation is deprecated.
+            |
+            |i_am_deprecated is deprecated. Called from foo.rb:1.
+            |i_am_deprecated is deprecated. Called from foo.rb:2.
+            |
+            |#{DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE}
+          EOS
+          expect(deprecation_stream.string).to eq expected.chomp
+        end
+
+        it "limits the deprecation warnings after 3 calls" do
+          5.times { |i| send_notification :deprecation, notification(:deprecated => 'i_am_deprecated', :call_site => "foo.rb:#{i + 1}") }
+          send_notification :deprecation_summary, null_notification
+          expected = <<-EOS.gsub(/^\s+\|/, '')
+            |
+            |Deprecation Warnings:
+            |
+            |i_am_deprecated is deprecated. Called from foo.rb:1.
+            |i_am_deprecated is deprecated. Called from foo.rb:2.
+            |i_am_deprecated is deprecated. Called from foo.rb:3.
+            |Too many uses of deprecated 'i_am_deprecated'. #{DeprecationFormatter::DEPRECATION_STREAM_NOTICE}
+            |
+            |#{DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE}
+          EOS
+          expect(deprecation_stream.string).to eq expected.chomp
+        end
+
+        it "limits :message deprecation warnings with different callsites after 3 calls" do
+          5.times do |n|
+            message = "This is a long string with some callsite info: /path/#{n}/to/some/file.rb:2#{n}3.  And some more stuff can come after."
+            send_notification :deprecation, notification(:message => message)
+          end
+          send_notification :deprecation_summary, null_notification
+          expected = <<-EOS.gsub(/^\s+\|/, '')
+            |
+            |Deprecation Warnings:
+            |
+            |This is a long string with some callsite info: /path/0/to/some/file.rb:203.  And some more stuff can come after.
+            |This is a long string with some callsite info: /path/1/to/some/file.rb:213.  And some more stuff can come after.
+            |This is a long string with some callsite info: /path/2/to/some/file.rb:223.  And some more stuff can come after.
+            |Too many similar deprecation messages reported, disregarding further reports. #{DeprecationFormatter::DEPRECATION_STREAM_NOTICE}
+            |
+            |#{DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE}
+          EOS
+          expect(deprecation_stream.string).to eq expected.chomp
+        end
+
+        it "prints the true deprecation count to the summary_stream" do
+          5.times { |i| send_notification :deprecation, notification(:deprecated => 'i_am_deprecated', :call_site => "foo.rb:#{i + 1}") }
+          5.times do |n|
+            send_notification :deprecation, notification(:message => "callsite info: /path/#{n}/to/some/file.rb:2#{n}3.  And some more stuff")
+          end
+          send_notification :deprecation_summary, null_notification
+          expect(summary_stream.string).to match(/10 deprecation warnings total/)
+        end
+
+        it 'does not print duplicate messages' do
+          3.times { send_notification :deprecation, notification(:deprecated => 'foo') }
+          send_notification :deprecation_summary, null_notification
+
+          expect(summary_stream.string).to match(/1 deprecation/)
+
+          expected = <<-EOS.gsub(/^\s+\|/, '')
+            |
+            |Deprecation Warnings:
+            |
+            |foo is deprecated.
+            |
+            |#{DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE}
+          EOS
+
+          expect(deprecation_stream.string).to eq expected.chomp
+        end
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/formatters/documentation_formatter_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'rspec/core/formatters/documentation_formatter'
+
+module RSpec::Core::Formatters
+  RSpec.describe DocumentationFormatter do
+    include FormatterSupport
+
+    before do
+      send_notification :start, start_notification(2)
+      allow(formatter).to receive(:color_enabled?).and_return(false)
+    end
+
+    def execution_result(values)
+      RSpec::Core::Example::ExecutionResult.new.tap do |er|
+        values.each { |name, value| er.__send__(:"#{name}=", value) }
+      end
+    end
+
+    it "numbers the failures" do
+      send_notification :example_failed, example_notification( double("example 1",
+               :description => "first example",
+               :execution_result => execution_result(:status => 'failed', :exception => Exception.new)
+              ))
+      send_notification :example_failed, example_notification( double("example 2",
+               :description => "second example",
+               :execution_result => execution_result(:status => 'failed', :exception => Exception.new)
+              ))
+
+      expect(output.string).to match(/first example \(FAILED - 1\)/m)
+      expect(output.string).to match(/second example \(FAILED - 2\)/m)
+    end
+
+    it "represents nested group using hierarchy tree" do
+      group = RSpec::Core::ExampleGroup.describe("root")
+      context1 = group.describe("context 1")
+      context1.example("nested example 1.1"){}
+      context1.example("nested example 1.2"){}
+
+      context11 = context1.describe("context 1.1")
+      context11.example("nested example 1.1.1"){}
+      context11.example("nested example 1.1.2"){}
+
+      context2 = group.describe("context 2")
+      context2.example("nested example 2.1"){}
+      context2.example("nested example 2.2"){}
+
+      group.run(reporter)
+
+      expect(output.string).to eql("
+root
+  context 1
+    nested example 1.1
+    nested example 1.2
+    context 1.1
+      nested example 1.1.1
+      nested example 1.1.2
+  context 2
+    nested example 2.1
+    nested example 2.2
+")
+    end
+
+    it "strips whitespace for each row" do
+      group = RSpec::Core::ExampleGroup.describe(" root ")
+      context1 = group.describe(" nested ")
+      context1.example(" example 1 ") {}
+      context1.example(" example 2 ", :pending => true){ fail }
+      context1.example(" example 3 ") { fail }
+
+      group.run(reporter)
+
+      expect(output.string).to eql("
+root
+  nested
+    example 1
+    example 2 (PENDING: No reason given)
+    example 3 (FAILED - 1)
+")
+    end
+
+    # The backrace is slightly different on JRuby so we skip there.
+    it 'produces the expected full output', :unless => RUBY_PLATFORM == 'java' do
+      output = run_example_specs_with_formatter("doc")
+      output.gsub!(/ +$/, '') # strip trailing whitespace
+
+      expect(output).to eq(<<-EOS.gsub(/^\s+\|/, ''))
+        |
+        |pending spec with no implementation
+        |  is pending (PENDING: Not yet implemented)
+        |
+        |pending command with block format
+        |  with content that would fail
+        |    is pending (PENDING: No reason given)
+        |  with content that would pass
+        |    fails (FAILED - 1)
+        |
+        |passing spec
+        |  passes
+        |
+        |failing spec
+        |  fails (FAILED - 2)
+        |
+        |a failing spec with odd backtraces
+        |  fails with a backtrace that has no file (FAILED - 3)
+        |  fails with a backtrace containing an erb file (FAILED - 4)
+        |
+        |#{expected_summary_output_for_example_specs}
+      EOS
+    end
+  end
+end

data/rspec-core/spec/rspec/core/formatters/helpers_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'rspec/core/formatters/helpers'
+
+RSpec.describe RSpec::Core::Formatters::Helpers do
+  helper = described_class
+
+  describe "format duration" do
+    context '< 1' do
+      it "returns '0.xxxxx seconds' formatted string" do
+        expect(helper.format_duration(0.123456)).to eq("0.12346 seconds")
+      end
+    end
+
+    context '> 1 and < 60' do
+      it "returns 'xx.xx seconds' formatted string" do
+        expect(helper.format_duration(45.51)).to eq("45.51 seconds")
+      end
+    end
+
+    context '> 60 and < 120' do
+      it "returns 'x minute xx.xx seconds' formatted string" do
+        expect(helper.format_duration(70.14)).to eq("1 minute 10.14 seconds")
+      end
+    end
+
+    context '> 120 and < 300' do
+      it "returns 'x minutes xx.x seconds' formatted string" do
+        expect(helper.format_duration(135.14)).to eq("2 minutes 15.1 seconds")
+      end
+    end
+
+    context '> 300' do
+      it "returns 'x minutes xx seconds' formatted string" do
+        expect(helper.format_duration(335.14)).to eq("5 minutes 35 seconds")
+      end
+    end
+
+    context '= 61' do
+      it "returns 'x minute x second' formatted string" do
+        expect(helper.format_duration(61)).to eq("1 minute 1 second")
+      end
+    end
+
+    context '= 1' do
+      it "returns 'x second' formatted string" do
+        expect(helper.format_duration(1)).to eq("1 second")
+      end
+    end
+
+    context 'with mathn loaded' do
+      include MathnIntegrationSupport
+
+      it "returns 'x minutes xx.x seconds' formatted string", :slow do
+        with_mathn_loaded do
+          expect(helper.format_duration(133.7)).to eq("2 minutes 13.7 seconds")
+        end
+      end
+    end
+  end
+
+  describe "format seconds" do
+    it "uses passed in precision if specified unless result is 0" do
+      expect(helper.format_seconds(0.01234, 2)).to eq("0.01")
+    end
+
+    context "sub second times" do
+      it "returns 5 digits of precision" do
+        expect(helper.format_seconds(0.000006)).to eq("0.00001")
+      end
+
+      it "strips off trailing zeroes beyond sub-second precision" do
+        expect(helper.format_seconds(0.020000)).to eq("0.02")
+      end
+
+      context "0" do
+        it "strips off trailing zeroes" do
+          expect(helper.format_seconds(0.00000000001)).to eq("0")
+        end
+      end
+
+      context "> 1" do
+        it "strips off trailing zeroes" do
+          expect(helper.format_seconds(1.00000000001)).to eq("1")
+        end
+      end
+    end
+
+    context "second and greater times" do
+
+      it "returns 2 digits of precision" do
+        expect(helper.format_seconds(50.330340)).to eq("50.33")
+      end
+
+      it "returns human friendly elasped time" do
+        expect(helper.format_seconds(50.1)).to eq("50.1")
+        expect(helper.format_seconds(5)).to eq("5")
+        expect(helper.format_seconds(5.0)).to eq("5")
+      end
+
+    end
+  end
+
+
+end

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

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rspec/core/formatters/html_formatter'
+require 'nokogiri'
+
+module RSpec
+  module Core
+    module Formatters
+      RSpec.describe HtmlFormatter do
+        include FormatterSupport
+
+        let(:root) { File.expand_path("#{File.dirname(__FILE__)}/../../../..") }
+        let(:expected_file) do
+          "#{File.dirname(__FILE__)}/html_formatted.html"
+        end
+
+        let(:generated_html) do
+          html = run_example_specs_with_formatter('html')
+
+          actual_doc = Nokogiri::HTML(html, &:noblanks)
+          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
+          File.read(expected_file)
+        end
+
+        before do
+          allow(RSpec.configuration).to receive(:load_spec_files) do
+            RSpec.configuration.files_to_run.map {|f| load File.expand_path(f) }
+          end
+        end
+
+        # Uncomment this group temporarily in order to overwrite the expected
+        # with actual.  Use with care!!!
+        describe "file generator", :if => ENV['GENERATE'] do
+          it "generates a new comparison file" do
+            Dir.chdir(root) do
+              File.open(expected_file, 'w') {|io| io.write(generated_html)}
+            end
+          end
+        end
+
+        def extract_backtrace_from(doc)
+          doc.search("div.backtrace").
+            collect {|e| e.at("pre").inner_html}.
+            collect {|e| e.split("\n")}.flatten.
+            select  {|e| e =~ /formatter_specs\.rb/}
+        end
+
+        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, &:noblanks)
+              actual_backtraces = extract_backtrace_from(actual_doc)
+              actual_doc.css("div.backtrace").remove
+
+              expected_doc = Nokogiri::HTML(expected_html, &:noblanks)
+              expected_backtraces = extract_backtrace_from(expected_doc)
+              expected_doc.search("div.backtrace").remove
+
+              expect(actual_doc.inner_html).to eq(expected_doc.inner_html)
+
+              expected_backtraces.each_with_index do |expected_line, i|
+                expected_path, expected_line_number, expected_suffix = expected_line.split(':')
+                actual_path, actual_line_number, actual_suffix = actual_backtraces[i].split(':')
+
+                expect(File.expand_path(actual_path)).to eq(File.expand_path(expected_path))
+                expect(actual_line_number).to eq(expected_line_number)
+                expect(actual_suffix).to eq(expected_suffix)
+              end
+            end
+          end
+
+          it "is identical to the one we designed manually", :pending => (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby') do
+            build_and_verify_formatter_output
+          end
+
+          context 'with mathn loaded' do
+            include MathnIntegrationSupport
+
+            it "is identical to the one we designed manually", :slow, :pending => (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby') do
+              with_mathn_loaded { build_and_verify_formatter_output }
+            end
+          end
+        end
+      end
+    end
+  end
+end