rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/core/option_parser_spec.rb

@@ -1,262 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  RSpec.describe OptionParser do
-    let(:output_file){ mock File }
-
-    before do
-      allow(RSpec).to receive(:deprecate)
-      allow(File).to receive(:open).with("foo.txt",'w') { (output_file) }
-    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
-
-    describe "--default_path" do
-      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 "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
-      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
-
-    %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
-      it 'enables warnings' do
-        options = Parser.parse(%w[--warnings])
-        expect(options[:warnings]).to eq true
-      end
-    end
-
-  end
-end

data/spec/rspec/core/ordering_spec.rb

@@ -1,102 +0,0 @@
-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/spec/rspec/core/pending_example_spec.rb

@@ -1,117 +0,0 @@
-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
-  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.metadata[:execution_result]
-      expect(result[:pending_fixed]).to eq(true)
-      expect(result[:status]).to eq("failed")
-    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")
-          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
-end