rspec-core 3.0.0.beta2 → 3.0.0.rc1

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

@@ -1,206 +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, null_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, 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 "10 examples, 3 failures, 4 pending"
-    end
-  end
-
-  describe "#dump_profile_slowest_examples", :slow do
-
-    before do
-      group = RSpec::Core::ExampleGroup.describe("group") do
-        example("example") { }
-      end
-      group.run(reporter)
-
-      allow(formatter).to receive(:examples) { group.examples }
-      allow(RSpec.configuration).to receive(:profile_examples) { 10 }
-    end
-
-    it "names the example" do
-      formatter.dump_profile_slowest_examples
-      expect(formatter.output_hash[:profile][:examples].first[:full_description]).to eq("group example")
-    end
-
-    it "provides example execution time" do
-      formatter.dump_profile_slowest_examples
-      expect(formatter.output_hash[:profile][:examples].first[:run_time]).not_to be_nil
-    end
-
-    it "has the summary of profile information" do
-      formatter.dump_profile_slowest_examples
-      expect(formatter.output_hash[:profile].keys).to match_array([:examples, :slowest, :total])
-    end
-  end
-
-  describe "#dump_profile_slowest_example_groups", :slow do
-    let(:group) do
-      RSpec::Core::ExampleGroup.describe("slow group") do
-        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
-
-    before do
-      allow(RSpec.configuration).to receive(:profile_examples) { 10 }
-      group.run(reporter)
-    end
-
-    context "with one example group" do
-      before { allow(formatter).to receive(:examples) { group.examples } }
-
-      it "doesn't profile a single example group" do
-        formatter.dump_profile_slowest_example_groups
-        expect(formatter.output_hash[:profile][:groups]).to be_empty
-      end
-    end
-
-    context "with multiple example groups", :slow do
-      before do
-        group2 = RSpec::Core::ExampleGroup.describe("fast group") do
-          example("example 1") { }
-          example("example 2") { }
-        end
-        group2.run(reporter)
-
-        allow(formatter).to receive(:examples) { group.examples + group2.examples }
-      end
-
-      it "provides the slowest example groups" do
-        formatter.dump_profile_slowest_example_groups
-        expect(formatter.output_hash).not_to be_empty
-      end
-
-      it "provides information" do
-        formatter.dump_profile_slowest_example_groups
-        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
-        formatter.dump_profile_slowest_example_groups
-        expect(formatter.output_hash[:profile][:groups].first[:description]).to eq("slow group")
-      end
-    end
-
-    it "depends on parent_groups to get the top level example group" do
-      ex = ""
-      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/spec/rspec/core/formatters/legacy_formatter_spec.rb

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

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

@@ -1,26 +0,0 @@
-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/spec/rspec/core/formatters_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Core::Formatters
-  describe Loader do
-
-    describe "#add(formatter)" do
-      let(:loader) { Loader.new reporter }
-      let(:output)     { StringIO.new }
-      let(:path)       { File.join(Dir.tmpdir, 'output.txt') }
-      let(:reporter)   { double "reporter", :register_listener => nil }
-
-      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
-
-      it "handles formatters that dont implement notifications" do
-        formatter_class = Struct.new(:output)
-        loader.add formatter_class, output
-        expect(loader.formatters.first).to be_an_instance_of(RSpec::Core::Formatters::LegacyFormatter)
-      end
-
-      context "when a legacy formatter is added" do
-        formatter_class = Struct.new(:output)
-
-        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
-
-        it "does not mistakenly add in the progress formatter" do
-          # When we issue a deprecation warning it triggers `setup_defaults`,
-          # which adds the progress formatter if it thinks no formatter has been
-          # added yet.
-          allow(RSpec).to receive(:warn_deprecation) do
-            loader.setup_default(StringIO.new, StringIO.new)
-          end
-
-          loader.add formatter_class, output
-
-          expect(loader.formatters.grep(RSpec::Core::Formatters::ProgressFormatter)).to eq([])
-        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
-      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
-  end
-end