opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,111 +0,0 @@
-# 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

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

@@ -1,183 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/json_formatter'
-require 'json'
-require 'rspec/core/reporter'
-
-# todo, someday:
-# it "lists the groups (describe and context) separately"
-# it "includes full 'execution_result'"
-# it "relativizes backtrace paths"
-# it "includes profile information (implements dump_profile)"
-# it "shows the pending message if one was given"
-# it "shows the seed if run was randomized"
-# it "lists pending specs that were fixed"
-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"; fail "eek" }
-    end
-    succeeding_line = __LINE__ - 4
-    failing_line = __LINE__ - 4
-    pending_line = __LINE__ - 4
-
-    now = Time.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
-    examples = formatter.output_hash[:examples]
-    failing_backtrace = examples[1][:exception][:backtrace]
-    this_file = relative_path(__FILE__)
-
-    expected = {
-      :examples => [
-        {
-          :description => "succeeds",
-          :full_description => "one apiece succeeds",
-          :status => "passed",
-          :file_path => this_file,
-          :line_number => succeeding_line,
-          :run_time => formatter.output_hash[:examples][0][:run_time]
-        },
-        {
-          :description => "fails",
-          :full_description => "one apiece fails",
-          :status => "failed",
-          :file_path => this_file,
-          :line_number => failing_line,
-          :run_time => formatter.output_hash[:examples][1][:run_time],
-          :exception => {
-            :class     => "RuntimeError",
-            :message   => "eek",
-            :backtrace => failing_backtrace
-          }
-        },
-        {
-          :description => "pends",
-          :full_description => "one apiece pends",
-          :status => "pending",
-          :file_path => this_file,
-          :line_number => pending_line,
-          :run_time => formatter.output_hash[:examples][2][:run_time]
-        },
-      ],
-      :summary => {
-        :duration => formatter.output_hash[:summary][:duration],
-        :example_count => 3,
-        :failure_count => 1,
-        :pending_count => 1,
-      },
-      :summary_line => "3 examples, 1 failure, 1 pending"
-    }
-    expect(formatter.output_hash).to eq expected
-    expect(output.string).to eq expected.to_json
-  end
-
-  describe "#stop" do
-    it "adds all examples to the output hash" do
-      send_notification :stop, stop_notification
-      expect(formatter.output_hash[:examples]).not_to be_nil
-    end
-  end
-
-  describe "#close" do
-    it "outputs the results as a JSON string" do
-      expect(output.string).to eq ""
-      send_notification :close, null_notification
-      expect(output.string).to eq("{}")
-    end
-  end
-
-  describe "#message" do
-    it "adds a message to the messages list" do
-      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
-      send_notification :dump_summary, summary_notification(1.0, examples(10), examples(3), examples(4), 0)
-      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 "10 examples, 3 failures, 4 pending"
-    end
-  end
-
-  describe "#dump_profile", :slow do
-
-    def profile *groups
-      groups.each { |group| group.run(reporter) }
-      examples = groups.map(&:examples).flatten
-      send_notification :dump_profile, profile_notification(0.5, examples, 10)
-    end
-
-    before do
-      formatter
-      config.profile_examples = 10
-    end
-
-    context "with one example group" do
-      before do
-        profile( RSpec::Core::ExampleGroup.describe("group") do
-          example("example") { }
-        end)
-      end
-
-      it "names the example" do
-        expect(formatter.output_hash[:profile][:examples].first[:full_description]).to eq("group example")
-      end
-
-      it "provides example execution time" do
-        expect(formatter.output_hash[:profile][:examples].first[:run_time]).not_to be_nil
-      end
-
-      it "doesn't profile a single example group" do
-        expect(formatter.output_hash[:profile][:groups]).to be_empty
-      end
-
-      it "has the summary of profile information" do
-        expect(formatter.output_hash[:profile].keys).to match_array([:examples, :groups, :slowest, :total])
-      end
-    end
-
-    context "with multiple example groups", :slow do
-      before do
-        example_clock = class_double(RSpec::Core::Time, :now => RSpec::Core::Time.now + 0.5)
-
-        group1 = RSpec::Core::ExampleGroup.describe("slow group") do
-          example("example") do |example|
-            # make it look slow without actually taking up precious time
-            example.clock = example_clock
-          end
-        end
-        group2 = RSpec::Core::ExampleGroup.describe("fast group") do
-          example("example 1") { }
-          example("example 2") { }
-        end
-        profile group1, group2
-      end
-
-      it "provides the slowest example groups" do
-        expect(formatter.output_hash).not_to be_empty
-      end
-
-      it "provides information" do
-        expect(formatter.output_hash[:profile][:groups].first.keys).to match_array([:total_time, :count, :description, :average, :location])
-      end
-
-      it "ranks the example groups by average time" do
-        expect(formatter.output_hash[:profile][:groups].first[:description]).to eq("slow group")
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/profile_formatter'
-
-RSpec.describe RSpec::Core::Formatters::ProfileFormatter do
-  include FormatterSupport
-
-  def profile *groups
-    groups.each { |group| group.run(reporter) }
-    examples = groups.map(&:examples).flatten
-    total_time = examples.map { |e| e.execution_result.run_time }.inject(&:+)
-    send_notification :dump_profile, profile_notification(total_time, examples, 10)
-  end
-
-  describe "#dump_profile", :slow do
-    example_line_number = nil
-
-    shared_examples_for "profiles examples" do
-      it "names the example" do
-        expect(output.string).to match(/group example/m)
-      end
-
-      it "prints the time" do
-        expect(output.string).to match(/0(\.\d+)? seconds/)
-      end
-
-      it "prints the path" do
-        filename = __FILE__.split(File::SEPARATOR).last
-        expect(output.string).to match(/#{filename}\:#{example_line_number}/)
-      end
-
-      it "prints the percentage taken from the total runtime" do
-        expect(output.string).to match(/, 100.0% of total time\):/)
-      end
-
-      it "doesn't profile a single example group" do
-        expect(output.string).not_to match(/slowest example groups/)
-      end
-    end
-
-    context "with one example group" do
-      before do
-        example_clock = class_double(RSpec::Core::Time, :now => RSpec::Core::Time.now + 0.5)
-
-        profile(RSpec::Core::ExampleGroup.describe("group") do
-          example("example") do |example|
-            # make it look slow without actually taking up precious time
-            example.clock = example_clock
-          end
-          example_line_number = __LINE__ - 4
-        end)
-      end
-
-      it_should_behave_like "profiles examples"
-    end
-
-    context "with multiple example groups" do
-      before do
-        example_clock = class_double(RSpec::Core::Time, :now => RSpec::Core::Time.now + 0.5)
-
-        group1 = RSpec::Core::ExampleGroup.describe("slow group") do
-          example("example") do |example|
-            # make it look slow without actually taking up precious time
-            example.clock = example_clock
-          end
-            example_line_number = __LINE__ - 4
-        end
-        group2 = RSpec::Core::ExampleGroup.describe("fast group") do
-          example("example 1") { }
-          example("example 2") { }
-        end
-        profile group1, group2
-      end
-
-      it "prints the slowest example groups" do
-        expect(output.string).to match(/slowest example groups/)
-      end
-
-      it "prints the time" do
-        expect(output.string).to match(/0(\.\d+)? seconds/)
-      end
-
-      it "ranks the example groups by average time" do
-        expect(output.string).to match(/slow group(.*)fast group/m)
-      end
-    end
-
-    it "depends on parent_groups to get the top level example group" do
-      ex = nil
-      group = RSpec::Core::ExampleGroup.describe
-      group.describe("group 2") do
-        describe "group 3" do
-          ex = example("nested example 1")
-        end
-      end
-
-      expect(ex.example_group.parent_groups.last).to eq(group)
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/progress_formatter'
-
-RSpec.describe RSpec::Core::Formatters::ProgressFormatter do
-  include FormatterSupport
-
-  before do
-    send_notification :start, start_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, examples(2), [], [], 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
-
-  # 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("progress")
-    output.gsub!(/ +$/, '') # strip trailing whitespace
-
-    expect(output).to eq(<<-EOS.gsub(/^\s+\|/, ''))
-      |**F.FFF
-      |
-      |#{expected_summary_output_for_example_specs}
-    EOS
-  end
-end