opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+module RSpec::Core
+  RSpec.describe FilterManager do
+    def opposite(name)
+      name =~ /^in/ ? name.sub(/^(in)/,'ex') : name.sub(/^(ex)/,'in')
+    end
+
+    subject(:filter_manager) { FilterManager.new }
+    let(:inclusions) { filter_manager.inclusions }
+    let(:exclusions) { filter_manager.exclusions }
+
+    %w[include inclusions exclude exclusions].each_slice(2) do |name, type|
+      describe "##{name}" do
+        subject(:rules) { send(type).rules }
+        let(:opposite_rules) { send(opposite(type)).rules }
+
+        it "merges #{type}" do
+          filter_manager.send name, :foo => :bar
+          filter_manager.send name, :baz => :bam
+          expect(rules).to eq(:foo => :bar, :baz => :bam)
+        end
+
+        it "overrides previous #{type} with (via merge)" do
+          filter_manager.send name, :foo => 1
+          filter_manager.send name, :foo => 2
+          expect(rules).to eq(:foo => 2)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send name, :foo => 2
+          expect(rules).to eq(:foo => 2)
+          expect(opposite_rules).to be_empty
+        end
+
+        if name == "include"
+          [:locations, :full_description].each do |filter|
+            context "with :#{filter}" do
+              it "clears previous inclusions" do
+                filter_manager.include :foo => :bar
+                filter_manager.include filter => "value"
+                expect(rules).to eq({filter => "value"})
+              end
+
+              it "clears previous exclusion" do
+                filter_manager.include :foo => :bar
+                filter_manager.include filter => "value"
+                expect(opposite_rules).to be_empty
+              end
+
+              it "does nothing when :#{filter} previously set" do
+                filter_manager.include filter => "a_value"
+                filter_manager.include :foo => :bar
+                expect(rules).to eq(filter => "a_value")
+              end
+            end
+          end
+        end
+      end
+
+      describe "##{name}_only" do
+        subject(:rules) { send(type).rules }
+        let(:opposite_rules) { send(opposite(type)).rules }
+
+        it "replaces existing #{type}" do
+          filter_manager.send name, :foo => 1, :bar => 2
+          filter_manager.send "#{name}_only", :foo => 3
+          expect(rules).to eq(:foo => 3)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_only", :foo => 2
+          expect(rules).to eq(:foo => 2)
+          expect(opposite_rules).to be_empty
+        end
+      end
+
+      describe "##{name}_with_low_priority" do
+        subject(:rules) { send(type).rules }
+        let(:opposite_rules) { send(opposite(type)).rules }
+
+        it "ignores new #{type} if same key exists" do
+          filter_manager.send name, :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          expect(rules).to eq(:foo => 1)
+        end
+
+        it "ignores new #{type} if same key exists in opposite" do
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 1
+          expect(rules).to be_empty
+          expect(opposite_rules).to eq(:foo => 1)
+        end
+
+        it "keeps new #{type} if same key exists in opposite but values are different" do
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          expect(rules).to eq(:foo => 2)
+          expect(opposite_rules).to eq(:foo => 1)
+        end
+      end
+    end
+
+    describe "#prune" do
+      def example_with(*args)
+        RSpec.describe("group", *args).example("example")
+      end
+
+      it "prefers location to exclusion filter" do
+        group = RSpec.describe("group")
+        included = group.example("include", :slow => true) {}
+        excluded = group.example("exclude") {}
+        filter_manager.add_location(__FILE__, [__LINE__ - 2])
+        filter_manager.exclude_with_low_priority :slow => true
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers location to exclusion filter on entire group" do
+        # We way want to change this behaviour in future, see:
+        # https://github.com/rspec/rspec-core/issues/779
+        group = RSpec.describe("group")
+        included = group.example("include", :slow => true) {}
+        excluded = example_with
+        filter_manager.add_location(__FILE__, [__LINE__ - 3])
+        filter_manager.exclude_with_low_priority :slow => true
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers description to exclusion filter" do
+        group = RSpec.describe("group")
+        included = group.example("include", :slow => true) {}
+        excluded = group.example("exclude") {}
+        filter_manager.include(:full_description => /include/)
+        filter_manager.exclude_with_low_priority :slow => true
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "includes objects with tags matching inclusions" do
+        included = example_with({:foo => :bar})
+        excluded = example_with
+        filter_manager.include :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "excludes objects with tags matching exclusions" do
+        included = example_with
+        excluded = example_with({:foo => :bar})
+        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 = example_with
+        excluded = example_with({:foo => :bar})
+        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 = example_with({:foo => :bar})
+        excluded = example_with
+        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 = example_with({:foo => :bar})
+        excluded = example_with
+        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 = example_with
+        excluded = example_with({:foo => :bar})
+        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
+      subject(:description) { inclusions.description }
+
+      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.include :foo => lambda { }
+
+        expect(description).not_to include(project_dir)
+        expect(description).not_to include(' (lambda)')
+        expect(description).not_to include('0x')
+      end
+    end
+
+    describe "#exclusions#description" do
+      subject(:description) { exclusions.description }
+
+      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.exclude :foo => lambda { }
+
+        expect(description).not_to include(project_dir)
+        expect(description).not_to include(' (lambda)')
+        expect(description).not_to include('0x')
+      end
+
+      it 'returns `{}` when it only contains the default filters' do
+        expect(description).to eq({}.inspect)
+      end
+
+      it 'includes other filters' do
+        filter_manager.exclude :foo => :bar
+        expect(description).to eq({ :foo => :bar }.inspect)
+      end
+
+      it 'includes an overriden :if filter' do
+        allow(RSpec).to receive(:deprecate)
+        filter_manager.exclude :if => :custom_filter
+        expect(description).to eq({ :if => :custom_filter }.inspect)
+      end
+
+      it 'includes an overriden :unless filter' do
+        allow(RSpec).to receive(:deprecate)
+        filter_manager.exclude :unless => :custom_filter
+        expect(description).to eq({ :unless => :custom_filter }.inspect)
+      end
+    end
+
+    describe ":if and :unless ExclusionFilters" do
+      def example_with_metadata(metadata)
+        value = nil
+        RSpec.describe("group") do
+          value = example('arbitrary example', metadata)
+        end
+        value
+      end
+
+      describe "the default :if filter" do
+        it "does not exclude a spec with  { :if => true } metadata" do
+          example = example_with_metadata(:if => true)
+          expect(filter_manager.exclude?(example)).to be_falsey
+        end
+
+        it "excludes a spec with  { :if => false } metadata" do
+          example = example_with_metadata(:if => false)
+          expect(filter_manager.exclude?(example)).to be_truthy
+        end
+
+        it "excludes a spec with  { :if => nil } metadata" do
+          example = example_with_metadata(:if => nil)
+          expect(filter_manager.exclude?(example)).to be_truthy
+        end
+
+        it "continues to be an exclusion even if exclusions are cleared" do
+          example = example_with_metadata(:if => false)
+          filter_manager.exclusions.clear
+          expect(filter_manager.exclude?(example)).to be_truthy
+        end
+      end
+
+      describe "the default :unless filter" do
+        it "excludes a spec with  { :unless => true } metadata" do
+          example = example_with_metadata(:unless => true)
+          expect(filter_manager.exclude?(example)).to be_truthy
+        end
+
+        it "does not exclude a spec with { :unless => false } metadata" do
+          example = example_with_metadata(:unless => false)
+          expect(filter_manager.exclude?(example)).to be_falsey
+        end
+
+        it "does not exclude a spec with { :unless => nil } metadata" do
+          example = example_with_metadata(:unless => nil)
+          expect(filter_manager.exclude?(example)).to be_falsey
+        end
+
+        it "continues to be an exclusion even if exclusions are cleared" do
+          example = example_with_metadata(:unless => true)
+          filter_manager.exclusions.clear
+          expect(filter_manager.exclude?(example)).to be_truthy
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rspec/core/formatters/base_text_formatter'
+
+RSpec.describe RSpec::Core::Formatters::BaseTextFormatter do
+  include FormatterSupport
+
+  context "when closing the formatter", :isolated_directory => true do
+    it 'does not close an already closed output stream' do
+      output = File.new("./output_to_close", "w")
+      formatter = described_class.new(output)
+      output.close
+
+      expect { formatter.close(RSpec::Core::Notifications::NullNotification) }.not_to raise_error
+    end
+  end
+
+  describe "#dump_summary" do
+    it "with 0s outputs pluralized (excluding pending)" do
+      send_notification :dump_summary, summary_notification(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(0, examples(1), examples(1), examples(1), 0)
+      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, examples(2), examples(2), examples(2), 0)
+      expect(output.string).to match("2 examples, 2 failures, 2 pending")
+    end
+
+    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)
+      examples = group.examples
+      send_notification :dump_summary, summary_notification(1, examples, examples, [], 0)
+      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, failed_examples_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
+
+    if String.method_defined?(:encoding)
+      context "with an exception that has a differently encoded message" do
+        it "runs without encountering an encoding exception" do
+          group.example("Mixing encodings, e.g. UTF-8: © and Binary") { raise "Error: \xC2\xA9".force_encoding("ASCII-8BIT") }
+          run_all_and_dump_failures
+          expect(output.string).to match(/RuntimeError:\n\s+Error: \?\?/m) # ?? because the characters dont encode properly
+        end
+      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 #shared_examples' do
+      it 'outputs the name and location' do
+        group.shared_examples '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 ' +
+            "#{RSpec::Core::Metadata.relative_path(__FILE__)}:#{line}"
+        )
+      end
+
+      context 'that contains nested example groups' do
+        it 'outputs the name and location' do
+          group.shared_examples '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 "custom_colors" do
+    it "uses the custom success color" do
+      RSpec.configure do |config|
+        config.color = true
+        config.tty = true
+        config.success_color = :cyan
+      end
+      send_notification :dump_summary, summary_notification(0, examples(1), [], [], 0)
+      expect(output.string).to include("\e[36m")
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'rspec/core/formatters/console_codes'
+
+RSpec.describe "RSpec::Core::Formatters::ConsoleCodes" do
+  let(:console_codes) { RSpec::Core::Formatters::ConsoleCodes }
+
+  describe "#console_code_for(code_or_symbol)" do
+    context "when given a VT100 integer code" do
+      it "returns the code" do
+        expect(console_codes.console_code_for(32)).to eq 32
+      end
+    end
+
+    context "when given a symbolic name" do
+      it "returns the code" do
+        expect(console_codes.console_code_for(:green)).to eq 32
+      end
+    end
+
+    context "when given an rspec code" do
+      it "returns the console code" do
+        RSpec.configuration.success_color = :blue # blue is 34
+        expect(console_codes.console_code_for(:success)).to eq 34
+      end
+    end
+
+    context "when given a nonexistant code" do
+      it "returns the code for white" do
+        expect(console_codes.console_code_for(:octarine)).to eq 37
+      end
+    end
+  end
+
+  describe "#wrap" do
+    before do
+      allow(RSpec.configuration).to receive(:color_enabled?) { true }
+    end
+
+    context "when given a VT100 integer code" do
+      it "formats the text with it" do
+        expect(console_codes.wrap('abc', 32)).to eq "\e[32mabc\e[0m"
+      end
+    end
+
+    context "when given a symbolic color name" do
+      it "translates it to the correct integer code and formats the text with it" do
+        expect(console_codes.wrap('abc', :green)).to eq "\e[32mabc\e[0m"
+      end
+    end
+
+    context "when given an rspec code" do
+      it "returns the console code" do
+        RSpec.configuration.success_color = :blue # blue is 34
+        expect(console_codes.wrap('abc', :success)).to eq "\e[34mabc\e[0m"
+      end
+    end
+
+
+    context "when given :bold" do
+      it "formats the text as bold" do
+        expect(console_codes.wrap('abc', :bold)).to eq "\e[1mabc\e[0m"
+      end
+    end
+  end
+end