vagrant-unbundled 1.9.5.1 → 1.9.7.1

data/vendor/bundle/ruby/2.4.0/gems/rspec-core-2.14.8/spec/rspec/core/option_parser_spec.rb

@@ -1,242 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  describe OptionParser do
-    let(:output_file){ mock File }
-
-    before do
-      RSpec.stub(:deprecate)
-      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
-        RSpec.should_receive(:deprecate)
-        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 "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
-        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(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/vendor/bundle/ruby/2.4.0/gems/rspec-core-2.14.8/spec/rspec/core/pending_example_spec.rb

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