opal-rspec 0.4.3 → 0.5.0.beta1

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

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

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

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

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'rspec/core/formatters/snippet_extractor'
+
+module RSpec
+  module Core
+    module Formatters
+      RSpec.describe SnippetExtractor do
+        it "falls back on a default message when it doesn't understand a line" do
+          expect(RSpec::Core::Formatters::SnippetExtractor.new.snippet_for("blech")).to eq(["# Couldn't get snippet for blech", 1])
+        end
+
+        it "falls back on a default message when it doesn't find the file" do
+         expect(RSpec::Core::Formatters::SnippetExtractor.new.lines_around("blech", 8)).to eq("# Couldn't get snippet for blech")
+        end
+
+        it "falls back on a default message when it gets a security error" do
+          message = nil
+          safely do
+            message = RSpec::Core::Formatters::SnippetExtractor.new.lines_around("blech", 8)
+          end
+          expect(message).to eq("# Couldn't get snippet for blech")
+        end
+      end
+    end
+  end
+end

data/rspec-core/spec/rspec/core/formatters_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+require 'pathname'
+
+module RSpec::Core::Formatters
+  describe Loader do
+
+    let(:output)   { StringIO.new }
+    let(:reporter) { instance_double "Reporter", :register_listener => nil }
+    let(:loader)   { Loader.new reporter }
+
+    describe "#add(formatter)" do
+      let(:path) { File.join(Dir.tmpdir, 'output.txt') }
+
+      it "adds to the list of formatters" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ Symbol)" do
+        loader.add :documentation, output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by name (w/ String)" do
+        loader.add 'documentation', output
+        expect(loader.formatters.first).to be_an_instance_of(DocumentationFormatter)
+      end
+
+      it "finds a formatter by class" do
+        formatter_class = Class.new(BaseTextFormatter)
+        Loader.formatters[formatter_class] = []
+        loader.add formatter_class, output
+        expect(loader.formatters.first).to be_an_instance_of(formatter_class)
+      end
+
+      it "finds a formatter by class name" do
+        stub_const("CustomFormatter", Class.new(BaseFormatter))
+        Loader.formatters[CustomFormatter] = []
+        loader.add "CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(CustomFormatter)
+      end
+
+      context "when a legacy formatter is added with RSpec::LegacyFormatters" do
+        formatter_class = Struct.new(:output)
+        let(:formatter) { double "formatter", :notifications => notifications }
+        let(:notifications) { [:a, :b, :c] }
+
+        before do
+          class_double("RSpec::LegacyFormatters", :load_formatter => formatter).as_stubbed_const
+        end
+
+        it "loads formatters from the external gem" do
+          loader.add formatter_class, output
+          expect(loader.formatters).to eq [formatter]
+        end
+
+        it "subscribes the formatter to the notifications the adaptor implements" do
+          expect(reporter).to receive(:register_listener).with(formatter, *notifications)
+          loader.add formatter_class, output
+        end
+      end
+
+      context "when a legacy formatter is added without RSpec::LegacyFormatters" do
+        formatter_class = Struct.new(:output)
+
+        before do
+          allow_deprecation
+        end
+
+        it "issues a deprecation" do
+          expect_warn_deprecation_with_call_site(__FILE__, __LINE__ + 2,
+            /The #{formatter_class} formatter uses the deprecated formatter interface/)
+          loader.add formatter_class, output
+        end
+      end
+
+      it "finds a formatter by class fully qualified name" do
+        stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+        Loader.formatters[RSpec::CustomFormatter] = []
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "requires a formatter file based on its fully qualified name" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter') do
+          stub_const("RSpec::CustomFormatter", (Class.new(BaseFormatter)))
+          Loader.formatters[RSpec::CustomFormatter] = []
+        end
+        loader.add "RSpec::CustomFormatter", output
+        expect(loader.formatters.first).to be_an_instance_of(RSpec::CustomFormatter)
+      end
+
+      it "raises NameError if class is unresolvable" do
+        expect(loader).to receive(:require).with('rspec/custom_formatter3')
+        expect { loader.add "RSpec::CustomFormatter3", output }.to raise_error(NameError)
+      end
+
+      it "raises ArgumentError if formatter is unknown" do
+        expect { loader.add :progresss, output }.to raise_error(ArgumentError)
+      end
+
+      context "with a 2nd arg defining the output" do
+        it "creates a file at that path and sets it as the output" do
+          loader.add('doc', path)
+          expect(loader.formatters.first.output).to be_a(File)
+          expect(loader.formatters.first.output.path).to eq(path)
+        end
+
+        it "accepts Pathname objects for file paths" do
+          pathname = Pathname.new(path)
+          loader.add('doc', pathname)
+          expect(loader.formatters.first.output).to be_a(File)
+          expect(loader.formatters.first.output.path).to eq(path)
+        end
+      end
+
+      context "when a duplicate formatter exists" do
+        before { loader.add :documentation, output }
+
+        it "doesn't add the formatter for the same output target" do
+          expect {
+            loader.add :documentation, output
+          }.not_to change { loader.formatters.length }
+        end
+
+        it "adds the formatter for different output targets" do
+          expect {
+            loader.add :documentation, path
+          }.to change { loader.formatters.length }
+        end
+      end
+    end
+
+    describe "#setup_default", "with profiling enabled" do
+      let(:setup_default) { loader.setup_default output, output }
+
+      before do
+        allow(RSpec.configuration).to receive(:profile_examples?) { true }
+      end
+
+      context "without an existing profile formatter" do
+        it "will add the profile formatter" do
+          allow(reporter).to receive(:registered_listeners).with(:dump_profile) { [] }
+          setup_default
+          expect(loader.formatters.last).to be_a ::RSpec::Core::Formatters::ProfileFormatter
+        end
+      end
+
+      context "when a formatter that implement #dump_profile is added" do
+        it "wont add the profile formatter" do
+          allow(reporter).to receive(:registered_listeners).with(:dump_profile) { [:json] }
+          setup_default
+          expect(
+            loader.formatters.map(&:class)
+          ).to_not include ::RSpec::Core::Formatters::ProfileFormatter
+        end
+      end
+    end
+  end
+end