rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/core/filter_manager_spec.rb

@@ -1,229 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Core
-  RSpec.describe FilterManager do
-    def opposite(name)
-      name =~ /^in/ ? name.sub(/^(in)/,'ex') : name.sub(/^(ex)/,'in')
-    end
-
-    %w[include inclusions exclude exclusions].each_slice(2) do |name, type|
-      describe "##{name}" do
-        it "merges #{type}" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send name, :foo => :bar
-          filter_manager.send name, :baz => :bam
-          expect(filter_manager.send(type)).to eq(:foo => :bar, :baz => :bam)
-        end
-
-        it "overrides previous #{type} with (via merge)" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send name, :foo => 1
-          filter_manager.send name, :foo => 2
-          expect(filter_manager.send(type)).to eq(:foo => 2)
-        end
-
-        it "deletes matching opposites" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send opposite(name), :foo => 1
-          filter_manager.send name, :foo => 2
-          expect(filter_manager.send(type)).to eq(:foo => 2)
-          expect(filter_manager.send(opposite(type))).to be_empty
-        end
-
-        if name == "include"
-          [:locations, :line_numbers, :full_description].each do |filter|
-            context "with :#{filter}" do
-              it "clears previous inclusions" do
-                filter_manager = FilterManager.new
-                filter_manager.include :foo => :bar
-                filter_manager.include filter => "value"
-                expect(filter_manager.inclusions).to eq({filter => "value"})
-              end
-
-              it "clears previous exclusion" do
-                filter_manager = FilterManager.new
-                filter_manager.include :foo => :bar
-                filter_manager.include filter => "value"
-                expect(filter_manager.exclusions).to be_empty
-              end
-
-              it "does nothing when :#{filter} previously set" do
-                filter_manager = FilterManager.new
-                filter_manager.include filter => "a_value"
-                filter_manager.include :foo => :bar
-                expect(filter_manager.inclusions).to eq(filter => "a_value")
-              end
-            end
-          end
-        end
-      end
-
-      describe "##{name}!" do
-        it "replaces existing #{type}" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send name, :foo => 1, :bar => 2
-          filter_manager.send "#{name}!", :foo => 3
-          expect(filter_manager.send(type)).to eq(:foo => 3)
-        end
-
-        it "deletes matching opposites" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send opposite(name), :foo => 1
-          filter_manager.send "#{name}!", :foo => 2
-          expect(filter_manager.send(type)).to eq(:foo => 2)
-          expect(filter_manager.send(opposite(type))).to be_empty
-        end
-      end
-
-      describe "##{name}_with_low_priority" do
-        it "ignores new #{type} if same key exists" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send name, :foo => 1
-          filter_manager.send "#{name}_with_low_priority", :foo => 2
-          expect(filter_manager.send(type)).to eq(:foo => 1)
-        end
-
-        it "ignores new #{type} if same key exists in opposite" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send opposite(name), :foo => 1
-          filter_manager.send "#{name}_with_low_priority", :foo => 1
-          expect(filter_manager.send(type)).to be_empty
-          expect(filter_manager.send(opposite(type))).to eq(:foo => 1)
-        end
-
-        it "keeps new #{type} if same key exists in opposite but values are different" do
-          filter_manager = FilterManager.new
-          filter_manager.exclusions.clear # defaults
-          filter_manager.send opposite(name), :foo => 1
-          filter_manager.send "#{name}_with_low_priority", :foo => 2
-          expect(filter_manager.send(type)).to eq(:foo => 2)
-          expect(filter_manager.send(opposite(type))).to eq(:foo => 1)
-        end
-      end
-    end
-
-    describe "#prune" do
-      def filterable_object_with(args = {})
-        object = double('a filterable object')
-        allow(object).to receive(:any_apply?) { |f| Metadata.new(args).any_apply?(f) }
-        object
-      end
-
-      it "includes objects with tags matching inclusions" do
-        included = filterable_object_with({:foo => :bar})
-        excluded = filterable_object_with
-        filter_manager = FilterManager.new
-        filter_manager.include :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-
-      it "excludes objects with tags matching exclusions" do
-        included = filterable_object_with
-        excluded = filterable_object_with({:foo => :bar})
-        filter_manager = FilterManager.new
-        filter_manager.exclude :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-
-      it "prefers exclusion when matches previously set inclusion" do
-        included = filterable_object_with
-        excluded = filterable_object_with({:foo => :bar})
-        filter_manager = FilterManager.new
-        filter_manager.include :foo => :bar
-        filter_manager.exclude :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-
-      it "prefers inclusion when matches previously set exclusion" do
-        included = filterable_object_with({:foo => :bar})
-        excluded = filterable_object_with
-        filter_manager = FilterManager.new
-        filter_manager.exclude :foo => :bar
-        filter_manager.include :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-
-      it "prefers previously set inclusion when exclusion matches but has lower priority" do
-        included = filterable_object_with({:foo => :bar})
-        excluded = filterable_object_with
-        filter_manager = FilterManager.new
-        filter_manager.include :foo => :bar
-        filter_manager.exclude_with_low_priority :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-
-      it "prefers previously set exclusion when inclusion matches but has lower priority" do
-        included = filterable_object_with
-        excluded = filterable_object_with({:foo => :bar})
-        filter_manager = FilterManager.new
-        filter_manager.exclude :foo => :bar
-        filter_manager.include_with_low_priority :foo => :bar
-        expect(filter_manager.prune([included, excluded])).to eq([included])
-      end
-    end
-
-    describe "#inclusions#description" do
-      it 'cleans up the description' do
-        project_dir = File.expand_path('.')
-        expect(lambda { }.inspect).to include(project_dir)
-        expect(lambda { }.inspect).to include(' (lambda)') if RUBY_VERSION > '1.9'
-        expect(lambda { }.inspect).to include('0x')
-
-        filter_manager = FilterManager.new
-        filter_manager.include :foo => lambda { }
-
-        expect(filter_manager.inclusions.description).not_to include(project_dir)
-        expect(filter_manager.inclusions.description).not_to include(' (lambda)')
-        expect(filter_manager.inclusions.description).not_to include('0x')
-      end
-    end
-
-    describe "#exclusions#description" do
-      it 'cleans up the description' do
-        project_dir = File.expand_path('.')
-        expect(lambda { }.inspect).to include(project_dir)
-        expect(lambda { }.inspect).to include(' (lambda)') if RUBY_VERSION > '1.9'
-        expect(lambda { }.inspect).to include('0x')
-
-        filter_manager = FilterManager.new
-        filter_manager.exclude :foo => lambda { }
-
-        expect(filter_manager.exclusions.description).not_to include(project_dir)
-        expect(filter_manager.exclusions.description).not_to include(' (lambda)')
-        expect(filter_manager.exclusions.description).not_to include('0x')
-      end
-
-      it 'returns `{}` when it only contains the default filters' do
-        filter_manager = FilterManager.new
-        expect(filter_manager.exclusions.description).to eq({}.inspect)
-      end
-
-      it 'includes other filters' do
-        filter_manager = FilterManager.new
-        filter_manager.exclude :foo => :bar
-        expect(filter_manager.exclusions.description).to eq({ :foo => :bar }.inspect)
-      end
-
-      it 'includes an overriden :if filter' do
-        allow(RSpec).to receive(:deprecate)
-        filter_manager = FilterManager.new
-        filter_manager.exclude :if => :custom_filter
-        expect(filter_manager.exclusions.description).to eq({ :if => :custom_filter }.inspect)
-      end
-
-      it 'includes an overriden :unless filter' do
-        allow(RSpec).to receive(:deprecate)
-        filter_manager = FilterManager.new
-        filter_manager.exclude :unless => :custom_filter
-        expect(filter_manager.exclusions.description).to eq({ :unless => :custom_filter }.inspect)
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/base_formatter'
-
-RSpec.describe RSpec::Core::Formatters::BaseFormatter do
-  include FormatterSupport
-
-  describe "read_failed_line" do
-    it "deals gracefully with a heterogeneous language stack trace" do
-      exception = double(:Exception, :backtrace => [
-        "at Object.prototypeMethod (foo:331:18)",
-        "at Array.forEach (native)",
-        "at a_named_javascript_function (/some/javascript/file.js:39:5)",
-        "/some/line/of/ruby.rb:14"
-      ])
-      example = double(:Example, :file_path => __FILE__)
-      expect {
-        formatter.send(:read_failed_line, exception, example)
-      }.not_to raise_error
-    end
-
-    it "deals gracefully with a security error" do
-      exception = double(:Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"])
-      example = double(:Example, :file_path => __FILE__)
-      safely do
-        expect {
-          formatter.send(:read_failed_line, exception, example)
-        }.not_to raise_error
-      end
-    end
-
-    context "when ruby reports a bogus line number in the stack trace" do
-      it "reports the filename and that it was unable to find the matching line" do
-        exception = double(:Exception, :backtrace => [ "#{__FILE__}:10000000" ])
-        example = double(:Example, :file_path => __FILE__)
-
-        msg = formatter.send(:read_failed_line, exception, example)
-        expect(msg).to include("Unable to find matching line")
-      end
-    end
-
-    context "when String alias to_int to_i" do
-      before do
-        String.class_eval do
-          alias :to_int :to_i
-        end
-      end
-
-      after do
-        String.class_eval do
-          undef to_int
-        end
-      end
-
-      it "doesn't hang when file exists" do
-        exception = double(:Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"])
-
-        example = double(:Example, :file_path => __FILE__)
-        expect(formatter.send(:read_failed_line, exception, example)).to eql(
-          %Q{        exception = double(:Exception, :backtrace => [ "\#{__FILE__}:\#{__LINE__}"])\n})
-      end
-
-    end
-  end
-end

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

@@ -1,303 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/base_text_formatter'
-
-RSpec.describe RSpec::Core::Formatters::BaseTextFormatter do
-  include FormatterSupport
-
-  describe "#dump_summary" do
-    it "with 0s outputs pluralized (excluding pending)" do
-      send_notification :dump_summary, summary_notification(0, 0, 0, 0)
-      expect(output.string).to match("0 examples, 0 failures")
-    end
-
-    it "with 1s outputs singular (including pending)" do
-      send_notification :dump_summary, summary_notification(1, 1, 1, 1)
-      expect(output.string).to match("1 example, 1 failure, 1 pending")
-    end
-
-    it "with 2s outputs pluralized (including pending)" do
-      send_notification :dump_summary, summary_notification(2, 2, 2, 2)
-      expect(output.string).to match("2 examples, 2 failures, 2 pending")
-    end
-  end
-
-  describe "#dump_commands_to_rerun_failed_examples" do
-    it "includes command to re-run each failed example" do
-      group = RSpec::Core::ExampleGroup.describe("example group") do
-        it("fails") { fail }
-      end
-      line = __LINE__ - 2
-      group.run(reporter)
-      formatter.dump_commands_to_rerun_failed_examples
-      expect(output.string).to include("rspec #{RSpec::Core::Metadata::relative_path("#{__FILE__}:#{line}")} # example group fails")
-    end
-  end
-
-  describe "#dump_failures" do
-    let(:group) { RSpec::Core::ExampleGroup.describe("group name") }
-
-    before { allow(RSpec.configuration).to receive(:color_enabled?) { false } }
-
-    def run_all_and_dump_failures
-      group.run(reporter)
-      send_notification :dump_failures, null_notification
-    end
-
-    it "preserves formatting" do
-      group.example("example name") { expect("this").to eq("that") }
-
-      run_all_and_dump_failures
-
-      expect(output.string).to match(/group name example name/m)
-      expect(output.string).to match(/(\s+)expected: \"that\"\n\1     got: \"this\"/m)
-    end
-
-    context "with an exception without a message" do
-      it "does not throw NoMethodError" do
-        exception_without_message = Exception.new()
-        allow(exception_without_message).to receive(:message) { nil }
-        group.example("example name") { raise exception_without_message }
-        expect { run_all_and_dump_failures }.not_to raise_error
-      end
-
-      it "preserves ancestry" do
-        example = group.example("example name") { raise "something" }
-        run_all_and_dump_failures
-        expect(example.example_group.parent_groups.size).to eq 1
-      end
-    end
-
-    context "with an exception that has an exception instance as its message" do
-      it "does not raise NoMethodError" do
-        gonzo_exception = RuntimeError.new
-        allow(gonzo_exception).to receive(:message) { gonzo_exception }
-        group.example("example name") { raise gonzo_exception }
-        expect { run_all_and_dump_failures }.not_to raise_error
-      end
-    end
-
-    context "with an instance of an anonymous exception class" do
-      it "substitutes '(anonymous error class)' for the missing class name" do
-        exception = Class.new(StandardError).new
-        group.example("example name") { raise exception }
-        run_all_and_dump_failures
-        expect(output.string).to include('(anonymous error class)')
-      end
-    end
-
-    context "with an exception class other than RSpec" do
-      it "does not show the error class" do
-        group.example("example name") { raise NameError.new('foo') }
-        run_all_and_dump_failures
-        expect(output.string).to match(/NameError/m)
-      end
-    end
-
-    context "with a failed expectation (rspec-expectations)" do
-      it "does not show the error class" do
-        group.example("example name") { expect("this").to eq("that") }
-        run_all_and_dump_failures
-        expect(output.string).not_to match(/RSpec/m)
-      end
-    end
-
-    context "with a failed message expectation (rspec-mocks)" do
-      it "does not show the error class" do
-        group.example("example name") { expect("this").to receive("that") }
-        run_all_and_dump_failures
-        expect(output.string).not_to match(/RSpec/m)
-      end
-    end
-
-    context 'for #share_examples_for' do
-      it 'outputs the name and location' do
-
-        group.share_examples_for 'foo bar' do
-          it("example name") { expect("this").to eq("that") }
-        end
-
-        line = __LINE__.next
-        group.it_should_behave_like('foo bar')
-
-        run_all_and_dump_failures
-
-        expect(output.string).to include(
-          'Shared Example Group: "foo bar" called from ' +
-            "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
-        )
-      end
-
-      context 'that contains nested example groups' do
-        it 'outputs the name and location' do
-          group.share_examples_for 'foo bar' do
-            describe 'nested group' do
-              it("example name") { expect("this").to eq("that") }
-            end
-          end
-
-          line = __LINE__.next
-          group.it_should_behave_like('foo bar')
-
-          run_all_and_dump_failures
-
-          expect(output.string).to include(
-            'Shared Example Group: "foo bar" called from ' +
-              "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
-          )
-        end
-      end
-    end
-  end
-
-  describe "#dump_profile_slowest_examples", :slow do
-    example_line_number = nil
-
-    before do
-      group = RSpec::Core::ExampleGroup.describe("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
-        example_line_number = __LINE__ - 4
-      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(output.string).to match(/group example/m)
-    end
-
-    it "prints the time" do
-      formatter.dump_profile_slowest_examples
-      expect(output.string).to match(/0(\.\d+)? seconds/)
-    end
-
-    it "prints the path" do
-      formatter.dump_profile_slowest_examples
-      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
-      formatter.dump_profile_slowest_examples
-      expect(output.string).to match(/, 100.0% of total time\):/)
-    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
-      group.run(reporter)
-      allow(RSpec.configuration).to receive(:profile_examples) { 10 }
-    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(output.string).not_to match(/slowest example groups/)
-      end
-    end
-
-    context "with multiple example groups" 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 "prints the slowest example groups" do
-        formatter.dump_profile_slowest_example_groups
-        expect(output.string).to match(/slowest example groups/)
-      end
-
-      it "prints the time" do
-        formatter.dump_profile_slowest_example_groups
-        expect(output.string).to match(/0(\.\d+)? seconds/)
-      end
-
-      it "ranks the example groups by average time" do
-        formatter.dump_profile_slowest_example_groups
-        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 = ""
-      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
-
-  describe "custom_colors" do
-    it "uses the custom success color" do
-      RSpec.configure do |config|
-        config.color_enabled = true
-        config.tty = true
-        config.success_color = :cyan
-      end
-      send_notification :dump_summary, summary_notification(0, 1, 0, 0)
-      expect(output.string).to include("\e[36m")
-    end
-  end
-
-  describe "#colorize" do
-    it "accepts a VT100 integer code and formats the text with it" do
-       expect(formatter.colorize('abc', 32)).to eq "\e[32mabc\e[0m"
-    end
-
-    it "accepts a symbol as a color parameter and translates it to the correct integer code, then formats the text with it" do
-       expect(formatter.colorize('abc', :green)).to eq "\e[32mabc\e[0m"
-    end
-
-    it "accepts a non-default color symbol as a parameter and translates it to the correct integer code, then formats the text with it" do
-       expect(formatter.colorize('abc', :cyan)).to eq "\e[36mabc\e[0m"
-    end
-  end
-
-  described_class::VT100_COLORS.each do |name, number|
-    next if name == :black
-
-    describe "##{name}" do
-      before do
-        allow(RSpec.configuration).to receive(:color_enabled?) { true }
-        allow(RSpec).to receive(:deprecate)
-      end
-
-      it "prints the text using the color code for #{name}" do
-        expect(formatter.send(name, "text")).to eq("\e[#{number}mtext\e[0m")
-      end
-
-      it "prints a deprecation warning" do
-        expect(RSpec).to receive(:deprecate) {|*args|
-          expect(args.first).to match(/#{name}/)
-        }
-        formatter.send(name, "text")
-      end
-    end
-  end
-
-end