rspec-core 2.99.0 → 3.0.0

data/spec/rspec/core/option_parser_spec.rb

@@ -1,297 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe OptionParser do
-    let(:output_file){ mock File }
-
-    before do
-      File.stub(:open).with("foo.txt",'w') { (output_file) }
-    end
-
-    it "does not parse empty args" do
-      parser = Parser.new
-      OptionParser.should_not_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"
-
-      parser.should_receive(:abort) do |msg|
-        expect(msg).to include('use --help', option)
-      end
-
-      parser.parse!([option])
-    end
-
-    describe "--formatter" do
-      it "is deprecated" do
-        expect_deprecation_with_no_call_site(%r{`--formatter`})
-        Parser.parse!(%w[--formatter doc])
-      end
-
-      it "gets converted to --format" do
-        options = Parser.parse!(%w[--formatter doc])
-        expect(options[:formatters].first).to eq(["doc"])
-      end
-    end
-
-    describe "--default_path" do
-      it "is deprecated" do
-        expect_deprecation_with_no_call_site(%r{`--default_path`})
-        Parser.parse!(%w[--default_path foo])
-      end
-
-      it "gets converted to --default-path" do
-        options = Parser.parse!(%w[--default_path foo])
-        expect(options[:default_path]).to eq "foo"
-      end
-    end
-
-    describe "--line_number" do
-      it "is deprecated" do
-        expect_deprecation_with_no_call_site(%r{`--line-number`/`-l`})
-        Parser.parse!(%w[--line_number 3])
-      end
-
-      it "gets converted to --line-number" do
-        options = Parser.parse!(%w[--line_number 3])
-        expect(options[:line_numbers]).to eq ["3"]
-      end
-    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[--line-number -l].each do |option|
-      describe option do
-        it "sets the line number of an example to run" do
-          options = Parser.parse!([option, "3"])
-          expect(options[:line_numbers]).to eq ["3"]
-        end
-
-        it "is deprecated" do
-          expect_deprecation_with_no_call_site(%r{`--line-number`/`-l`})
-          Parser.parse!([option, "3"])
-        end
-      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
-
-    describe "--deprecation-out" do
-      it 'configures the deprecation stream' do
-        expect {
-          Parser.parse!(['--deprecation-out', 'path/to/file.log'])
-        }.to change { RSpec.configuration.deprecation_stream }.to('path/to/file.log')
-      end
-
-      it 'sets the deprecation stream before processing other options that issue deprecations' do
-        expect(RSpec).to receive(:deprecate) do
-          expect(RSpec.configuration.deprecation_stream).to eq('path/to/file.log')
-        end
-
-        Parser.parse!(['--line-number', '3', '--deprecation-out', 'path/to/file.log'])
-      end
-
-      it 'issues an appropriate error when no file arg is provided' do
-        out_error = Parser.parse!(['--out']) rescue $!
-        expect {
-          Parser.parse!(['--deprecation-out'])
-        }.to raise_error(out_error.class, out_error.message.gsub('--out', '--deprecation-out'))
-      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
-
-    %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
-        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
-
-      context "with default" do
-        it 'defines the order as defined' do
-          options = Parser.parse!(['--order', 'default'])
-          expect(options[:order]).to eq('defined')
-        end
-
-        it 'prints a deprecation warning' do
-          expect_deprecation_with_no_call_site(/default/)
-          Parser.parse!(['--order', 'default'])
-        end
-      end
-
-      context "with defined" do
-        it 'defines the order as defined' do
-          options = Parser.parse!(['--order', 'defined'])
-          expect(options[:order]).to eq('defined')
-        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(Kernel).to receive(:warn)
-        options = Parser.parse!(%w[--profile some/path])
-        expect(options[:profile_examples]).to eq true
-      end
-
-      it 'warns when accidentally combined with path' do
-        expect(Kernel).to receive(:warn) do |msg|
-          expect(msg).to match "Non integer specified as profile count"
-        end
-        options = Parser.parse!(%w[--profile some/path])
-        expect(options[:profile_examples]).to eq true
-      end
-    end
-
-    describe '--warning' do
-      it 'enables warnings' do
-        options = Parser.parse!(%w[--warnings])
-        expect(options[:warnings]).to eq true
-      end
-    end
-
-  end
-end

data/spec/rspec/core/pending_example_spec.rb

@@ -1,260 +0,0 @@
-require 'spec_helper'
-
-describe "an example" do
-  matcher :be_pending_with do |message|
-    match do |example|
-      example.pending? && example.metadata[:execution_result][:pending_message] == message
-    end
-
-    failure_message_for_should do |example|
-      "expected: example pending with #{message.inspect}\n     got: #{example.metadata[:execution_result][:pending_message].inspect}"
-    end
-  end
-
-  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
-        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
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-      expect(example).to be_pending_with('No reason given')
-    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_pending_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
-        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 'shows upgrade warning' do
-      expect_warn_deprecation_with_call_site(
-        "pending_example_spec.rb", __LINE__ + 4
-      )
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-    end
-  end
-
-  context "with no docstring" do
-    context "declared with the pending method" do
-      it "does not have 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 match(/example at/)
-      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")
-        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 "skip with a block" do
-    it "does not execute the block" do
-      called = false
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          skip { called = true }
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-      expect(called).to eq(false)
-    end
-  end
-
-  context "with a block" do
-    def run_example(*pending_args, &block)
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending(*pending_args) { block.call if block }
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-      example
-    end
-
-    it 'shows upgrade warning' do
-      expect_warn_deprecation_with_call_site(
-        "pending_example_spec.rb", __LINE__ + 4
-      )
-      group = RSpec::Core::ExampleGroup.describe('group') do
-        it "does something" do
-          pending {}
-        end
-      end
-      example = group.examples.first
-      example.run(group.new, double.as_null_object)
-    end
-
-    context "that fails" do
-      def run_example(*pending_args)
-        super(*pending_args) { raise ArgumentError.new }
-      end
-
-      context "when given no options" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because")).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because", :if => true)).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example(:if => true)).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and fails" do
-          expect(run_example(                :if => false)).to fail_with(ArgumentError)
-          expect(run_example("just because", :if => false)).to fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and fails" do
-          expect(run_example(                :unless => true)).to fail_with(ArgumentError)
-          expect(run_example("just because", :unless => true)).to fail_with(ArgumentError)
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "is listed as pending with the supplied message" do
-          expect(run_example("just because", :unless => false)).to be_pending_with("just because")
-        end
-
-        it "is listed as pending with the default message when no message is given" do
-          expect(run_example(:unless => false)).to be_pending_with(RSpec::Core::Pending::NO_REASON_GIVEN)
-        end
-      end
-    end
-
-    context "that fails due to a failed message expectation" do
-      def run_example(*pending_args)
-        super(*pending_args) { "foo".should_receive(:bar) }
-      end
-
-      it "passes" do
-        expect(run_example("just because")).to be_pending
-      end
-    end
-
-    context "that passes" do
-      def run_example(*pending_args)
-        super(*pending_args) { expect(3).to eq(3) }
-      end
-
-      context "when given no options" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because")).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example).to                 fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a truthy :if option" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because", :if => true)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example(                :if => true)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-
-      context "when given a falsey :if option" do
-        it "runs the example and it passes" do
-          expect(run_example(                :if => false)).to pass
-          expect(run_example("just because", :if => false)).to pass
-        end
-      end
-
-      context "when given a truthy :unless option" do
-        it "runs the example and it passes" do
-          expect(run_example(                :unless => true)).to pass
-          expect(run_example("just because", :unless => true)).to pass
-        end
-      end
-
-      context "when given a falsey :unless option" do
-        it "fails with a PendingExampleFixedError" do
-          expect(run_example("just because", :unless => false)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-          expect(run_example(                :unless => false)).to fail_with(RSpec::Core::Pending::PendingExampleFixedError)
-        end
-      end
-    end
-  end
-end

data/spec/rspec/core/pending_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe RSpec::Core::Pending do
-  describe 'PendingDeclaredInExample' do
-    before { allow_deprecation }
-
-    it 'is an alternate reference to SkipDeclaredInExample' do
-      expect(::RSpec::Core::Pending::PendingDeclaredInExample).to \
-        be(::RSpec::Core::Pending::SkipDeclaredInExample)
-    end
-
-    it 'prints a deprecation warning' do
-      expect_deprecation_with_call_site(
-        __FILE__,
-        __LINE__ + 3,
-        /PendingDeclaredInExample/
-      )
-      ::RSpec::Core::Pending::PendingDeclaredInExample
-    end
-
-    specify 'the const_missing hook raises for other undefined constants' do
-      expect {
-        ::RSpec::Core::Pending::SomeUndefinedConst
-      }.to raise_error(NameError, /uninitialized constant/)
-    end
-  end
-end