rspec-core 2.99.0 → 3.0.0

data/spec/rspec/core/filter_manager_spec.rb

@@ -1,246 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Core
-  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 "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')
-        object.stub(: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) unless defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /\A1\.7/
-        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) unless defined?(JRUBY_VERSION) && JRUBY_VERSION =~ /\A1\.7/
-        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 'deprecates an overridden :if filter' do
-        expect(RSpec).to receive(:deprecate).with(/exclude\(:if/)
-        filter_manager = FilterManager.new
-        filter_manager.exclude :if => :custom_filter
-      end
-
-      it 'deprecates an :if filter overridden with low priority' do
-        expect(RSpec).to receive(:deprecate).with(/exclude\(:if/)
-        filter_manager = FilterManager.new
-        filter_manager.exclude_with_low_priority :if => :custom_filter
-      end
-
-      it 'deprecates an overridden :unless filter' do
-        expect(RSpec).to receive(:deprecate).with(/exclude\(:unless/)
-        filter_manager = FilterManager.new
-        filter_manager.exclude :unless => :custom_filter
-      end
-
-      it 'deprecates an :unless filter overridden with low priority' do
-        expect(RSpec).to receive(:deprecate).with(/exclude\(:unless/)
-        filter_manager = FilterManager.new
-        filter_manager.exclude_with_low_priority :unless => :custom_filter
-      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,108 +0,0 @@
-require 'spec_helper'
-require 'rspec/core/formatters/base_formatter'
-
-describe RSpec::Core::Formatters::BaseFormatter do
-
-  let(:output)    { StringIO.new }
-  let(:formatter) { RSpec::Core::Formatters::BaseFormatter.new(output) }
-
-  describe "backtrace_line" do
-    it "trims current working directory" do
-      expect(formatter.__send__(:backtrace_line, File.expand_path(__FILE__))).to eq("./spec/rspec/core/formatters/base_formatter_spec.rb")
-    end
-
-    it "leaves the original line intact" do
-      original_line = File.expand_path(__FILE__)
-      formatter.__send__(:backtrace_line, original_line)
-      expect(original_line).to eq(File.expand_path(__FILE__))
-    end
-
-    it "deals gracefully with a security error" do
-      safely do
-        formatter.__send__(:backtrace_line, __FILE__)
-        # on some rubies, this doesn't raise a SecurityError; this test just
-        # assures that if it *does* raise an error, the error is caught inside
-      end
-    end
-  end
-
-  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
-        pending("This issue still exists on JRuby, but should be resolved shortly: https://github.com/rspec/rspec-core/issues/295", :if => RUBY_PLATFORM == 'java')
-        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
-
-  describe "#format_backtrace" do
-    let(:rspec_expectations_dir) { "/path/to/rspec-expectations/lib" }
-    let(:rspec_core_dir) { "/path/to/rspec-core/lib" }
-    let(:backtrace) do
-      [
-        "#{rspec_expectations_dir}/rspec/matchers/operator_matcher.rb:51:in `eval_match'",
-        "#{rspec_expectations_dir}/rspec/matchers/operator_matcher.rb:29:in `=='",
-        "./my_spec.rb:5",
-        "#{rspec_core_dir}/rspec/core/example.rb:52:in `run'",
-        "#{rspec_core_dir}/rspec/core/runner.rb:37:in `run'",
-        RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE,
-        "./my_spec.rb:3"
-      ]
-    end
-
-    it "removes lines from rspec and lines that come before the invocation of the at_exit autorun hook" do
-      expect(formatter.format_backtrace(backtrace, double.as_null_object)).to eq(["./my_spec.rb:5"])
-    end
-  end
-
-end