opal-rspec 0.6.2 → 0.7.0.rc.1

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

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core::Notifications
-  describe FailedExampleNotification do
-    before do
-      allow(RSpec.configuration).to receive(:color_enabled?).and_return(true)
-    end
-
-    it "uses the default color for the shared example backtrace line" do
-      example = nil
-      group = RSpec::Core::ExampleGroup.describe "testing" do
-        shared_examples_for "a" do
-          example = it "fails" do
-            expect(1).to eq(2)
-          end
-        end
-        it_behaves_like "a"
-      end
-      group.run
-      fne = FailedExampleNotification.new(example)
-      lines = fne.colorized_message_lines
-      expect(lines).to include(match("\\e\\[37mShared Example Group:"))
-    end
-  end
-end

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

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

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