opal-rspec 0.4.3 → 0.5.0.beta1

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'rspec/core/notifications'
+
+RSpec.describe "FailedExampleNotification" do
+  include FormatterSupport
+
+  let(:notification) { ::RSpec::Core::Notifications::FailedExampleNotification.new(example) }
+
+  before do
+    allow(example).to receive(:file_path) { __FILE__ }
+  end
+
+  # ported from `base_formatter_spec` should be refactored by final
+  describe "#read_failed_line" do
+    context "when backtrace is a heterogeneous language stack trace" do
+      let(:exception) do
+        instance_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"
+        ])
+      end
+
+      it "is handled gracefully" do
+        expect { notification.send(:read_failed_line) }.not_to raise_error
+      end
+    end
+
+    context "when backtrace will generate a security error" do
+      let(:exception) { instance_double(Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"]) }
+
+      it "is handled gracefully" do
+        safely do
+          expect { notification.send(:read_failed_line) }.not_to raise_error
+        end
+      end
+    end
+
+    context "when ruby reports a bogus line number in the stack trace" do
+      let(:exception) { instance_double(Exception, :backtrace => [ "#{__FILE__}:10000000"]) }
+
+      it "reports the filename and that it was unable to find the matching line" do
+        expect(notification.send(:read_failed_line)).to include("Unable to find matching line")
+      end
+    end
+
+    context "when String alias to_int to_i" do
+      before do
+        String.class_exec do
+          alias :to_int :to_i
+        end
+      end
+
+      after do
+        String.class_exec do
+          undef to_int
+        end
+      end
+
+      let(:exception) { instance_double(Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"]) }
+
+      it "doesn't hang when file exists" do
+        expect(notification.send(:read_failed_line).strip).to eql(
+          %Q[let(:exception) { instance_double(Exception, :backtrace => [ "\#{__FILE__}:\#{__LINE__}"]) }])
+      end
+
+    end
+  end
+
+  describe '#message_lines' do
+    let(:exception) { instance_double(Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"], :message => 'Test exception') }
+    let(:example_group) { class_double(RSpec::Core::ExampleGroup, :metadata => {}, :parent_groups => [], :location => "#{__FILE__}:#{__LINE__}") }
+
+    before do
+      allow(example).to receive(:example_group) { example_group }
+    end
+
+    it 'should return failure_lines without color' do
+      lines = notification.message_lines
+      expect(lines[0]).to match %r{\AFailure\/Error}
+      expect(lines[1]).to match %r{\A\s*Test exception\z}
+    end
+
+    it 'returns failures_lines without color when they are part of a shared example group' do
+      allow(example_group).to receive(:metadata) { {:shared_group_name => 'double shared group'} }
+      lines = notification.message_lines
+      expect(lines[0]).to match %r{\AFailure\/Error}
+      expect(lines[1]).to match %r{\A\s*Test exception\z}
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+require "spec_helper"
+
+module RSpec::Core
+  RSpec.describe OptionParser do
+    before do
+      allow(RSpec.configuration).to receive(:reporter) do
+        fail "OptionParser is not allowed to access `config.reporter` since we want " +
+             "ConfigurationOptions to have the chance to set `deprecation_stream` " +
+             "(based on `--deprecation-out`) before the deprecation formatter is " +
+             "initialized by the reporter instantiation. If you need to issue a deprecation, " +
+             "populate an `options[:deprecations]` key and have ConfigurationOptions " +
+             "issue the deprecation after configuring `deprecation_stream`"
+      end
+    end
+
+    it "does not parse empty args" do
+      parser = Parser.new
+      expect(OptionParser).not_to receive(:new)
+      parser.parse([])
+    end
+
+    it "proposes you to use --help and returns an error on incorrect argument" do
+      parser = Parser.new
+      option = "--my_wrong_arg"
+
+      expect(parser).to receive(:abort) do |msg|
+        expect(msg).to include('use --help', option)
+      end
+
+      parser.parse([option])
+    end
+
+    {
+      '--init'         => ['-i','--I'],
+      '--default-path' => ['-d'],
+      '--dry-run'      => ['-d'],
+      '--drb-port'     => ['-d'],
+    }.each do |long, shorts|
+      shorts.each do |option|
+        it "won't parse #{option} as a shorthand for #{long}" do
+          parser = Parser.new
+
+          expect(parser).to receive(:abort) do |msg|
+            expect(msg).to include('use --help', option)
+          end
+
+          parser.parse([option])
+        end
+      end
+    end
+
+    it "won't display invalid options in the help output" do
+      def generate_help_text
+        parser = Parser.new
+        allow(parser).to receive(:exit)
+        parser.parse(["--help"])
+      end
+
+      useless_lines = /^\s*--?\w+\s*$\n/
+
+      expect { generate_help_text }.to_not output(useless_lines).to_stdout
+    end
+
+    describe "--default-path" do
+      it "sets the default path where RSpec looks for examples" do
+        options = Parser.parse(%w[--default-path foo])
+        expect(options[:default_path]).to eq "foo"
+      end
+    end
+
+    %w[--format -f].each do |option|
+      describe option do
+        it "defines the formatter" do
+          options = Parser.parse([option, 'doc'])
+          expect(options[:formatters].first).to eq(["doc"])
+        end
+      end
+    end
+
+    %w[--out -o].each do |option|
+      describe option do
+        let(:options) { Parser.parse([option, 'out.txt']) }
+
+        it "sets the output stream for the formatter" do
+          expect(options[:formatters].last).to eq(['progress', 'out.txt'])
+        end
+
+        context "with multiple formatters" do
+          context "after last formatter" do
+            it "sets the output stream for the last formatter" do
+              options = Parser.parse(['-f', 'progress', '-f', 'doc', option, 'out.txt'])
+              expect(options[:formatters][0]).to eq(['progress'])
+              expect(options[:formatters][1]).to eq(['doc', 'out.txt'])
+            end
+          end
+
+          context "after first formatter" do
+            it "sets the output stream for the first formatter" do
+              options = Parser.parse(['-f', 'progress', option, 'out.txt', '-f', 'doc'])
+              expect(options[:formatters][0]).to eq(['progress', 'out.txt'])
+              expect(options[:formatters][1]).to eq(['doc'])
+            end
+          end
+        end
+      end
+    end
+
+    describe "--deprecation-out" do
+      it 'sets the deprecation stream' do
+        options = Parser.parse(["--deprecation-out", "path/to/log"])
+        expect(options).to include(:deprecation_stream => "path/to/log")
+      end
+    end
+
+    %w[--example -e].each do |option|
+      describe option do
+        it "escapes the arg" do
+          options = Parser.parse([option, "this (and that)"])
+          expect(options[:full_description].length).to eq(1)
+          expect("this (and that)").to match(options[:full_description].first)
+        end
+      end
+    end
+
+    %w[--pattern -P].each do |option|
+      describe option do
+        it "sets the filename pattern" do
+          options = Parser.parse([option, 'spec/**/*.spec'])
+          expect(options[:pattern]).to eq('spec/**/*.spec')
+        end
+      end
+    end
+
+    %w[--tag -t].each do |option|
+      describe option do
+        context "without ~" do
+          it "treats no value as true" do
+            options = Parser.parse([option, 'foo'])
+            expect(options[:inclusion_filter]).to eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse([option, 'foo:true'])
+            expect(options[:inclusion_filter]).to eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse([option, 'foo:nil'])
+            expect(options[:inclusion_filter]).to eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse([option, 'foo:false'])
+            expect(options[:inclusion_filter]).to eq(:foo => false)
+          end
+
+          it "merges muliple invocations" do
+            options = Parser.parse([option, 'foo:false', option, 'bar:true', option, 'foo:true'])
+            expect(options[:inclusion_filter]).to eq(:foo => true, :bar => true)
+          end
+
+          it "treats 'any_string' as 'any_string'" do
+            options = Parser.parse([option, 'foo:any_string'])
+            expect(options[:inclusion_filter]).to eq(:foo => 'any_string')
+          end
+
+          it "treats ':any_sym' as :any_sym" do
+            options = Parser.parse([option, 'foo::any_sym'])
+            expect(options[:inclusion_filter]).to eq(:foo => :any_sym)
+          end
+
+          it "treats '42' as 42" do
+            options = Parser.parse([option, 'foo:42'])
+            expect(options[:inclusion_filter]).to eq(:foo => 42)
+          end
+
+          it "treats '3.146' as 3.146" do
+            options = Parser.parse([option, 'foo:3.146'])
+            expect(options[:inclusion_filter]).to eq(:foo => 3.146)
+          end
+        end
+
+        context "with ~" do
+          it "treats no value as true" do
+            options = Parser.parse([option, '~foo'])
+            expect(options[:exclusion_filter]).to eq(:foo => true)
+          end
+
+          it "treats 'true' as true" do
+            options = Parser.parse([option, '~foo:true'])
+            expect(options[:exclusion_filter]).to eq(:foo => true)
+          end
+
+          it "treats 'nil' as nil" do
+            options = Parser.parse([option, '~foo:nil'])
+            expect(options[:exclusion_filter]).to eq(:foo => nil)
+          end
+
+          it "treats 'false' as false" do
+            options = Parser.parse([option, '~foo:false'])
+            expect(options[:exclusion_filter]).to eq(:foo => false)
+          end
+        end
+      end
+    end
+
+    describe "--order" do
+      it "is nil by default" do
+        expect(Parser.parse([])[:order]).to be_nil
+      end
+
+      %w[rand random].each do |option|
+        context "with #{option}" do
+          it "defines the order as random" do
+            options = Parser.parse(['--order', option])
+            expect(options[:order]).to eq(option)
+          end
+        end
+      end
+    end
+
+    describe "--seed" do
+      it "sets the order to rand:SEED" do
+        options = Parser.parse(%w[--seed 123])
+        expect(options[:order]).to eq("rand:123")
+      end
+    end
+
+    describe '--profile' do
+      it 'sets profile_examples to true by default' do
+        options = Parser.parse(%w[--profile])
+        expect(options[:profile_examples]).to eq true
+      end
+
+      it 'sets profile_examples to supplied int' do
+        options = Parser.parse(%w[--profile 10])
+        expect(options[:profile_examples]).to eq 10
+      end
+
+      it 'sets profile_examples to true when accidentally combined with path' do
+        allow_warning
+        options = Parser.parse(%w[--profile some/path])
+        expect(options[:profile_examples]).to eq true
+      end
+
+      it 'warns when accidentally combined with path' do
+        expect_warning_without_call_site "Non integer specified as profile count"
+        options = Parser.parse(%w[--profile some/path])
+        expect(options[:profile_examples]).to eq true
+      end
+    end
+
+    describe '--warning' do
+      around do |ex|
+        verbose = $VERBOSE
+        ex.run
+        $VERBOSE = verbose
+      end
+
+      it 'immediately enables warnings so that warnings are issued for files loaded by `--require`' do
+        $VERBOSE = false
+
+        expect {
+          Parser.parse(%w[--warnings])
+        }.to change { $VERBOSE }.from(false).to(true)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+module RSpec
+  module Core
+    module Ordering
+      RSpec.describe Identity do
+        it "does not affect the ordering of the items" do
+          expect(Identity.new.order([1, 2, 3])).to eq([1, 2, 3])
+        end
+      end
+
+      RSpec.describe Random do
+        describe '.order' do
+          subject { described_class.new(configuration) }
+
+          let(:configuration)  { RSpec::Core::Configuration.new }
+          let(:items)          { 10.times.map { |n| n } }
+          let(:shuffled_items) { subject.order items }
+
+          it 'shuffles the items randomly' do
+            expect(shuffled_items).to match_array items
+            expect(shuffled_items).to_not eq items
+          end
+
+          context 'given multiple calls' do
+            it 'returns the items in the same order' do
+              expect(subject.order(items)).to eq shuffled_items
+            end
+          end
+
+          context 'given randomization has been seeded explicitly' do
+            before { @seed = srand }
+            after  { srand @seed }
+
+            it "does not affect the global random number generator" do
+              srand 123
+              val1, val2 = rand(1_000), rand(1_000)
+
+              subject
+
+              srand 123
+              subject.order items
+              expect(rand(1_000)).to eq(val1)
+              subject.order items
+              expect(rand(1_000)).to eq(val2)
+            end
+          end
+        end
+      end
+
+      RSpec.describe Custom do
+        it 'uses the block to order the list' do
+          strategy = Custom.new(proc { |list| list.reverse })
+
+          expect(strategy.order([1, 2, 3, 4])).to eq([4, 3, 2, 1])
+        end
+      end
+
+      RSpec.describe Registry do
+        let(:configuration) { Configuration.new }
+        subject(:registry) { Registry.new(configuration) }
+
+        describe "#used_random_seed?" do
+          it 'returns false if the random orderer has not been used' do
+            expect(registry.used_random_seed?).to be false
+          end
+
+          it 'returns false if the random orderer has been fetched but not used' do
+            expect(registry.fetch(:random)).to be_a(Random)
+            expect(registry.used_random_seed?).to be false
+          end
+
+          it 'returns true if the random orderer has been used' do
+            registry.fetch(:random).order([1, 2])
+            expect(registry.used_random_seed?).to be true
+          end
+        end
+
+        describe "#fetch" do
+          it "gives the registered ordering when called with a symbol" do
+            ordering = Object.new
+            subject.register(:falcon, ordering)
+
+            expect(subject.fetch(:falcon)).to be ordering
+          end
+
+          context "when given an unrecognized symbol" do
+            it 'invokes the given block and returns its value' do
+              expect(subject.fetch(:falcon) { :fallback }).to eq(:fallback)
+            end
+
+            it 'raises an error if no block is given' do
+              expect {
+                subject.fetch(:falcon)
+              }.to raise_error(IndexError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+RSpec.describe "an example" do
+  context "declared pending with metadata" do
+    it "uses the value assigned to :pending as the message" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        example "example", :pending => 'just because' do
+          fail
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_pending_with('just because')
+    end
+
+    it "sets the message to 'No reason given' if :pending => true" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        example "example", :pending => true do
+          fail
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_pending_with('No reason given')
+    end
+
+    it "passes if a mock expectation is not satisifed" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        example "example", :pending => "because" do
+          expect(RSpec).to receive(:a_message_in_a_bottle)
+        end
+      end
+
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_pending_with('because')
+      expect(example.execution_result.status).to eq(:pending)
+    end
+
+    it "does not mutate the :pending attribute of the user metadata when handling mock expectation errors" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        example "example", :pending => "because" do
+          expect(RSpec).to receive(:a_message_in_a_bottle)
+        end
+      end
+
+      group.run
+      example = group.examples.first
+      expect(example.metadata[:pending]).to be_truthy
+    end
+  end
+
+  context "made pending with `define_derived_metadata`" do
+    before do
+      RSpec.configure do |config|
+        config.define_derived_metadata(:not_ready) do |meta|
+          meta[:pending] ||= "Not ready"
+        end
+      end
+    end
+
+    it 'has a pending result if there is an error' do
+      group = RSpec.describe "group" do
+        example "something", :not_ready do
+          boom
+        end
+      end
+
+      group.run
+      example = group.examples.first
+      expect(example).to be_pending_with("Not ready")
+    end
+
+    it 'fails if there is no error' do
+      group = RSpec.describe "group" do
+        example "something", :not_ready do
+        end
+      end
+
+      group.run
+      example = group.examples.first
+      expect(example.execution_result.status).to be(:failed)
+      expect(example.execution_result.exception.message).to include("Expected example to fail")
+    end
+  end
+
+  context "with no block" do
+    it "is listed as pending with 'Not yet implemented'" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "has no block"
+      end
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_skipped_with('Not yet implemented')
+    end
+  end
+
+  context "with no args" do
+    it "is listed as pending with the default message" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending
+          fail
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
+    end
+
+    it "fails when the rest of the example passes" do
+      called = false
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending
+          called = true
+        end
+      end
+
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(called).to eq(true)
+      result = example.execution_result
+      expect(result.pending_fixed).to eq(true)
+      expect(result.status).to eq(:failed)
+    end
+
+    it "does not mutate the :pending attribute of the user metadata when the rest of the example passes" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending
+        end
+      end
+
+      group.run
+      example = group.examples.first
+      expect(example.metadata).to include(:pending => true)
+    end
+  end
+
+  context "with no docstring" do
+    context "declared with the pending method" do
+      it "has an auto-generated description" do
+        group = RSpec::Core::ExampleGroup.describe('group') do
+          it "checks something" do
+            expect((3+4)).to eq(7)
+          end
+          pending do
+            expect("string".reverse).to eq("gnirts")
+          end
+        end
+        example = group.examples.last
+        example.run(group.new, double.as_null_object)
+        expect(example.description).to eq('should eq "gnirts"')
+      end
+    end
+
+    context "after another example with some assertion" do
+      it "does not show any message" do
+        group = RSpec::Core::ExampleGroup.describe('group') do
+          it "checks something" do
+            expect((3+4)).to eq(7)
+          end
+          specify do
+            pending
+          end
+        end
+        example = group.examples.last
+        example.run(group.new, double.as_null_object)
+        expect(example.description).to match(/example at/)
+      end
+    end
+  end
+
+  context "with a message" do
+    it "is listed as pending with the supplied message" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "does something" do
+          pending("just because")
+          fail
+        end
+      end
+      example = group.examples.first
+      example.run(group.new, double.as_null_object)
+      expect(example).to be_pending_with('just because')
+    end
+  end
+
+  context "with a block" do
+    it "fails with an ArgumentError stating the syntax is deprecated" do
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "calls pending with a block" do
+          pending("with invalid syntax") do
+            :no_op
+          end
+          fail
+        end
+      end
+      example = group.examples.first
+      group.run
+      expect(example).to fail_with ArgumentError
+      expect(example.exception.message).to match(
+        /Passing a block within an example is now deprecated./
+      )
+    end
+
+    it "does not yield to the block" do
+      example_to_have_yielded = :did_not_yield
+      group = RSpec::Core::ExampleGroup.describe('group') do
+        it "calls pending with a block" do
+          pending("just because") do
+            example_to_have_yielded = :pending_block
+          end
+          fail
+        end
+      end
+      group.run
+      expect(example_to_have_yielded).to eq :did_not_yield
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe RSpec::Core::Pending do
+  it 'only defines methods that are part of the DSL' do
+    expect(RSpec::Core::Pending.instance_methods(false).map(&:to_sym)).to \
+      match_array([:pending, :skip])
+  end
+end