rspec-core 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/core/backtrace_formatter_spec.rb

@@ -1,230 +0,0 @@
-require "spec_helper"
-
-module RSpec::Core
-  RSpec.describe BacktraceFormatter do
-    def make_backtrace_formatter(exclusion_patterns=nil, inclusion_patterns=nil)
-      BacktraceFormatter.new.tap do |bc|
-        bc.exclusion_patterns = exclusion_patterns if exclusion_patterns
-        bc.inclusion_patterns = inclusion_patterns if inclusion_patterns
-      end
-    end
-
-    describe "defaults" do
-      it "excludes rspec files" do
-        expect(make_backtrace_formatter.exclude?("lib/rspec/core.rb")).to be true
-        expect(make_backtrace_formatter.exclude?("lib/rspec/core/foo.rb")).to be true
-        expect(make_backtrace_formatter.exclude?("lib/rspec/expectations/foo.rb")).to be true
-        expect(make_backtrace_formatter.exclude?("lib/rspec/matchers/foo.rb")).to be true
-        expect(make_backtrace_formatter.exclude?("lib/rspec/mocks/foo.rb")).to be true
-      end
-
-      it "excludes java files (for JRuby)" do
-        expect(make_backtrace_formatter.exclude?("org/jruby/RubyArray.java:2336")).to be true
-      end
-
-      it "excludes files within installed gems" do
-        expect(make_backtrace_formatter.exclude?('ruby-1.8.7-p334/gems/mygem-2.3.0/lib/mygem.rb')).to be true
-      end
-
-      it "includes files in projects containing 'gems' in the name" do
-        expect(make_backtrace_formatter.exclude?('code/my-gems-plugin/lib/plugin.rb')).to be false
-      end
-
-      it "includes something in the current working directory" do
-        expect(make_backtrace_formatter.exclude?("#{Dir.getwd}/arbitrary")).to be false
-      end
-
-      it "includes something in the current working directory even with a matching exclusion pattern" do
-        formatter = make_backtrace_formatter([/foo/])
-        expect(formatter.exclude? "#{Dir.getwd}/foo").to be false
-      end
-    end
-
-    describe "#format_backtrace" do
-      it "excludes lines from rspec libs by default", :unless => RSpec.windows_os? do
-        backtrace = [
-          "/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
-          "/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
-          "./my_spec.rb:5",
-          "/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
-          "/path/to/rspec-core/lib/rspec/core/foo.rb:37"
-        ]
-
-        expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./my_spec.rb:5"])
-      end
-
-      it "excludes lines from rspec libs by default", :if => RSpec.windows_os? do
-        backtrace = [
-          "\\path\\to\\rspec-expectations\\lib\\rspec\\expectations\\foo.rb:37",
-          "\\path\\to\\rspec-expectations\\lib\\rspec\\matchers\\foo.rb:37",
-          ".\\my_spec.rb:5",
-          "\\path\\to\\rspec-mocks\\lib\\rspec\\mocks\\foo.rb:37",
-          "\\path\\to\\rspec-core\\lib\\rspec\\core\\foo.rb:37"
-        ]
-
-        expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq([".\\my_spec.rb:5"])
-      end
-
-      it "excludes lines that come before at_exit autorun hook" do
-        backtrace = [
-          "./spec/my_spec.rb:7",
-          "./spec/my_spec.rb:5",
-          RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE,
-          "./spec/my_spec.rb:3"
-        ]
-        expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./spec/my_spec.rb:7", "./spec/my_spec.rb:5"])
-      end
-
-      context "when every line is filtered out" do
-        let(:backtrace) do
-          [
-            "/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
-            "/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
-            "/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
-            "/path/to/rspec-core/lib/rspec/core/foo.rb:37"
-          ]
-        end
-
-        it "includes full backtrace" do
-          expect(BacktraceFormatter.new.format_backtrace(backtrace).take(4)).to eq backtrace
-        end
-
-        it "adds a message explaining everything was filtered" do
-          expect(BacktraceFormatter.new.format_backtrace(backtrace).drop(4).join).to match(/Showing full backtrace/)
-        end
-      end
-
-      context "when rspec is installed in the current working directory" do
-        it "excludes lines from rspec libs by default", :unless => RSpec.windows_os? do
-          backtrace = [
-            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/expectations/foo.rb:37",
-            "#{Dir.getwd}/.bundle/path/to/rspec-expectations/lib/rspec/matchers/foo.rb:37",
-            "#{Dir.getwd}/my_spec.rb:5",
-            "#{Dir.getwd}/.bundle/path/to/rspec-mocks/lib/rspec/mocks/foo.rb:37",
-            "#{Dir.getwd}/.bundle/path/to/rspec-core/lib/rspec/core/foo.rb:37"
-          ]
-
-          expect(BacktraceFormatter.new.format_backtrace(backtrace)).to eq(["./my_spec.rb:5"])
-        end
-      end
-    end
-
-    describe "#full_backtrace=true" do
-      it "sets full_backtrace true" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        expect(formatter.full_backtrace?).to be true
-      end
-
-      it "preserves exclusion and inclusion patterns" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        expect(formatter.exclusion_patterns).to eq [/discard/]
-        expect(formatter.inclusion_patterns).to eq [/keep/]
-      end
-
-      it "keeps all lines, even those that match exclusions" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        expect(formatter.exclude? "discard").to be false
-      end
-    end
-
-    describe "#full_backtrace=false (after it was true)" do
-      it "sets full_backtrace false" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        formatter.full_backtrace = false
-        expect(formatter.full_backtrace?).to be false
-      end
-
-      it "preserves exclusion and inclusion patterns" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        formatter.full_backtrace = false
-        expect(formatter.exclusion_patterns).to eq [/discard/]
-        expect(formatter.inclusion_patterns).to eq [/keep/]
-      end
-
-      it "excludes lines that match exclusions" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        formatter.full_backtrace = true
-        formatter.full_backtrace = false
-        expect(formatter.exclude? "discard").to be true
-      end
-    end
-
-    describe "#backtrace_line" do
-      let(:formatter) { BacktraceFormatter.new }
-
-      it "trims current working directory" do
-        expect(formatter.__send__(:backtrace_line, File.expand_path(__FILE__))).to eq("./spec/rspec/core/backtrace_formatter_spec.rb")
-      end
-
-      it "preserves the original line" do
-        original_line = File.expand_path(__FILE__)
-        formatter.__send__(:backtrace_line, original_line)
-        expect(original_line).to eq(File.expand_path(__FILE__))
-      end
-
-      it "deals gracefully with a security error" do
-        safely do
-          formatter.__send__(:backtrace_line, __FILE__)
-          # on some rubies, this doesn't raise a SecurityError; this test just
-          # assures that if it *does* raise an error, the error is caught inside
-        end
-      end
-    end
-
-    context "with no patterns" do
-      it "keeps all lines" do
-        lines = ["/tmp/a_file", "some_random_text", "hello\330\271!"]
-        formatter = make_backtrace_formatter([], [])
-        expect(lines.all? {|line| formatter.exclude? line}).to be false
-      end
-
-      it "is considered a full backtrace" do
-        expect(make_backtrace_formatter([], []).full_backtrace?).to be true
-      end
-    end
-
-    context "with an exclusion pattern but no inclusion patterns" do
-      it "excludes lines that match the exclusion pattern" do
-        formatter = make_backtrace_formatter([/discard/],[])
-        expect(formatter.exclude? "discard me").to be true
-      end
-
-      it "keeps lines that do not match the exclusion pattern" do
-        formatter = make_backtrace_formatter([/discard/],[])
-        expect(formatter.exclude? "apple").to be false
-      end
-
-      it "is considered a partial backtrace" do
-        formatter = make_backtrace_formatter([/discard/],[])
-        expect(formatter.full_backtrace?).to be false
-      end
-    end
-
-    context "with an exclusion pattern and an inclusion pattern" do
-      it "excludes lines that match the exclusion pattern but not the inclusion pattern" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        expect(formatter.exclude? "discard").to be true
-      end
-
-      it "keeps lines that match both patterns" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        expect(formatter.exclude? "discard/keep").to be false
-      end
-
-      it "keeps lines that match neither pattern" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        expect(formatter.exclude? "fish").to be false
-      end
-
-      it "is considered a partial backtrace" do
-        formatter = make_backtrace_formatter([/discard/],[/keep/])
-        expect(formatter.full_backtrace?).to be false
-      end
-    end
-  end
-end

data/spec/rspec/core/command_line_spec.rb

@@ -1,112 +0,0 @@
-require "spec_helper"
-require "stringio"
-require 'tmpdir'
-
-module RSpec::Core
-  RSpec.describe CommandLine do
-
-    let(:out)    { StringIO.new         }
-    let(:err)    { StringIO.new         }
-    let(:config) { RSpec::configuration }
-    let(:world)  { RSpec::world         }
-
-    before do
-      allow(config.hooks).to receive(:run)
-    end
-
-    it "configures streams before command line options" do
-      allow(RSpec).to receive(:deprecate)  # remove this and should_receive when ordered
-      stdout = StringIO.new
-      allow(config).to receive(:load_spec_files)
-      allow(config).to receive(:reporter).and_return(double.as_null_object)
-      config.output_stream = $stdout
-
-      # this is necessary to ensure that color works correctly on windows
-      expect(config).to receive(:error_stream=).ordered
-      expect(config).to receive(:output_stream=).ordered
-      expect(config).to receive(:force).at_least(:once).ordered
-
-      command_line = build_command_line
-      command_line.run err, stdout
-    end
-
-    it "assigns ConfigurationOptions built from Array of options to @options" do
-      config_options = ConfigurationOptions.new(%w[--color])
-      command_line   = CommandLine.new(%w[--color])
-      expect(command_line.instance_eval { @options.options }).to eq(config_options.options)
-    end
-
-    it "assigns submitted ConfigurationOptions to @options" do
-      config_options = ConfigurationOptions.new(%w[--color])
-      command_line   = CommandLine.new(config_options)
-      expect(command_line.instance_eval { @options }).to be(config_options)
-    end
-
-    describe "#run" do
-      context "running files" do
-        include_context "spec files"
-
-        it "returns 0 if spec passes" do
-          command_line = build_command_line passing_spec_filename
-          expect(command_line.run(err, out)).to eq 0
-        end
-
-        it "returns 1 if spec fails" do
-          command_line = build_command_line failing_spec_filename
-          expect(command_line.run(err, out)).to eq 1
-        end
-
-        it "returns 2 if spec fails and --failure-exit-code is 2" do
-          command_line = build_command_line failing_spec_filename, "--failure-exit-code", "2"
-          expect(command_line.run(err, out)).to eq 2
-        end
-      end
-
-      context "running hooks" do
-        before { allow(config).to receive :load_spec_files }
-
-        it "runs before suite hooks" do
-          expect(config.hooks).to receive(:run).with(:before, :suite)
-          command_line = build_command_line
-          command_line.run err, out
-        end
-
-        it "runs after suite hooks" do
-          expect(config.hooks).to receive(:run).with(:after, :suite)
-          command_line = build_command_line
-          command_line.run err, out
-        end
-
-        it "runs after suite hooks even after an error" do
-          expect(config.hooks).to receive(:run).with(:before, :suite).and_raise "this error"
-          expect(config.hooks).to receive(:run).with(:after , :suite)
-          expect do
-            command_line = build_command_line
-            command_line.run err, out
-          end.to raise_error
-        end
-      end
-    end
-
-    describe "#run with custom output" do
-      before { allow(config).to receive_messages :files_to_run => [] }
-
-      let(:output_file) { File.new("#{Dir.tmpdir}/command_line_spec_output.txt", 'w') }
-
-      it "doesn't override output_stream" do
-        config.output_stream = output_file
-        command_line = build_command_line
-        command_line.run err, nil
-        expect(command_line.instance_eval { @configuration.output_stream }).to eq output_file
-      end
-    end
-
-    def build_command_line *args
-      CommandLine.new build_config_options(*args)
-    end
-
-    def build_config_options *args
-      ConfigurationOptions.new args
-    end
-  end
-end

data/spec/rspec/core/configuration_options_spec.rb

@@ -1,409 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-require 'rspec/core/drb_options'
-
-RSpec.describe RSpec::Core::ConfigurationOptions, :isolated_directory => true, :isolated_home => true do
-  include ConfigOptionsHelper
-
-  it "warns when HOME env var is not set", :unless => (RUBY_PLATFORM == 'java') do
-    without_env_vars 'HOME' do
-      expect_warning_with_call_site(__FILE__, __LINE__ + 1)
-      RSpec::Core::ConfigurationOptions.new([]).options
-    end
-  end
-
-  it "does not mutate the provided args array" do
-    args = ['-e', 'some spec']
-    RSpec::Core::ConfigurationOptions.new(args).options
-    expect(args).to eq(['-e', 'some spec'])
-  end
-
-  describe "#configure" do
-    let(:config) { RSpec::Core::Configuration.new }
-
-    it "sends libs before requires" do
-      opts = config_options_object(*%w[--require a/path -I a/lib])
-      config = double("config").as_null_object
-      expect(config).to receive(:libs=).ordered
-      expect(config).to receive(:requires=).ordered
-      opts.configure(config)
-    end
-
-    it "loads requires before loading specs" do
-      opts = config_options_object(*%w[-rspec_helper])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:requires=).ordered
-      expect(config).to receive(:get_files_to_run).ordered
-      opts.configure(config)
-      config.files_to_run
-    end
-
-    it "sets up load path and requires before formatter" do
-      opts = config_options_object(*%w[--require a/path -f a/formatter])
-      config = double("config").as_null_object
-      expect(config).to receive(:requires=).ordered
-      expect(config).to receive(:add_formatter).ordered
-      opts.configure(config)
-    end
-
-    it "sets default_path before loading specs" do
-      opts = config_options_object(*%w[--default_path spec])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:force).with(:default_path => 'spec').ordered
-      expect(config).to receive(:get_files_to_run).ordered
-      opts.configure(config)
-      config.files_to_run
-    end
-
-    it "sets `files_or_directories_to_run` before `requires` so users can check `files_to_run` in a spec_helper loaded by `--require`" do
-      opts = config_options_object(*%w[--require spec_helper])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:files_or_directories_to_run=).ordered
-      expect(config).to receive(:requires=).ordered
-      opts.configure(config)
-    end
-
-    it "sets default_path before `files_or_directories_to_run` since it relies on it" do
-      opts = config_options_object(*%w[--default_path spec])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:force).with(:default_path => 'spec').ordered
-      expect(config).to receive(:files_or_directories_to_run=).ordered
-      opts.configure(config)
-    end
-
-    it "sets pattern before loading specs" do
-      opts = config_options_object(*%w[--pattern **/*.spec])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:force).with(:pattern => '**/*.spec').ordered
-      expect(config).to receive(:get_files_to_run).ordered
-      opts.configure(config)
-      config.files_to_run
-    end
-
-    it "assigns inclusion_filter" do
-      opts = config_options_object(*%w[--tag awesome])
-      opts.configure(config)
-      expect(config.inclusion_filter).to have_key(:awesome)
-    end
-
-    it "merges the :exclusion_filter option with the default exclusion_filter" do
-      opts = config_options_object(*%w[--tag ~slow])
-      opts.configure(config)
-      expect(config.exclusion_filter).to have_key(:slow)
-    end
-
-    it "forces color_enabled" do
-      opts = config_options_object(*%w[--color])
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:force).with(:color => true)
-      opts.configure(config)
-    end
-
-    [
-      ["--failure-exit-code", "3", :failure_exit_code, 3 ],
-      ["--pattern", "foo/bar", :pattern, "foo/bar"],
-      ["--failure-exit-code", "37", :failure_exit_code, 37],
-      ["--default_path", "behavior", :default_path, "behavior"],
-      ["--order", "rand", :order, "rand"],
-      ["--seed", "37", :order, "rand:37"],
-      ["--drb-port", "37", :drb_port, 37]
-    ].each do |cli_option, cli_value, config_key, config_value|
-      it "forces #{config_key}" do
-        opts = config_options_object(cli_option, cli_value)
-        config = RSpec::Core::Configuration.new
-        expect(config).to receive(:force) do |pair|
-          expect(pair.keys.first).to eq(config_key)
-          expect(pair.values.first).to eq(config_value)
-        end
-        opts.configure(config)
-      end
-    end
-
-    it "merges --require specified by multiple configuration sources" do
-      with_env_vars 'SPEC_OPTS' => "--require file_from_env" do
-        opts = config_options_object(*%w[--require file_from_opts])
-        expect(config).to receive(:require).with("file_from_opts")
-        expect(config).to receive(:require).with("file_from_env")
-        opts.configure(config)
-      end
-    end
-
-    it "merges --I specified by multiple configuration sources" do
-      with_env_vars 'SPEC_OPTS' => "-I dir_from_env" do
-        opts = config_options_object(*%w[-I dir_from_opts])
-        expect(config).to receive(:libs=).with(["dir_from_opts", "dir_from_env"])
-        opts.configure(config)
-      end
-    end
-  end
-
-  describe "-c, --color, and --colour" do
-    it "sets :color => true" do
-      expect(parse_options('-c')).to include(:color => true)
-      expect(parse_options('--color')).to include(:color => true)
-      expect(parse_options('--colour')).to include(:color => true)
-    end
-  end
-
-  describe "--no-color" do
-    it "sets :color => false" do
-      expect(parse_options('--no-color')).to include(:color => false)
-    end
-
-    it "overrides previous :color => true" do
-      expect(parse_options('--color', '--no-color')).to include(:color => false)
-    end
-
-    it "gets overriden by a subsequent :color => true" do
-      expect(parse_options('--no-color', '--color')).to include(:color => true)
-    end
-  end
-
-  describe "-I" do
-    example "adds to :libs" do
-      expect(parse_options('-I', 'a_dir')).to include(:libs => ['a_dir'])
-    end
-    example "can be used more than once" do
-      expect(parse_options('-I', 'dir_1', '-I', 'dir_2')).to include(:libs => ['dir_1','dir_2'])
-    end
-  end
-
-  describe '--require' do
-    example "requires files" do
-      expect(parse_options('--require', 'a/path')).to include(:requires => ['a/path'])
-    end
-    example "can be used more than once" do
-      expect(parse_options('--require', 'path/1', '--require', 'path/2')).to include(:requires => ['path/1','path/2'])
-    end
-  end
-
-  describe "--format, -f" do
-    it "sets :formatter" do
-      [['--format', 'd'], ['-f', 'd'], '-fd'].each do |args|
-        expect(parse_options(*args)).to include(:formatters => [['d']])
-      end
-    end
-
-    example "can accept a class name" do
-      expect(parse_options('-fSome::Formatter::Class')).to include(:formatters => [['Some::Formatter::Class']])
-    end
-  end
-
-  describe "--profile, -p" do
-    it "sets :profile_examples" do
-      expect(parse_options('-p')).to include(:profile_examples => true)
-      expect(parse_options('--profile')).to include(:profile_examples => true)
-      expect(parse_options('-p', '4')).to include(:profile_examples => 4)
-      expect(parse_options('--profile', '3')).to include(:profile_examples => 3)
-    end
-  end
-
-  describe "--no-profile" do
-    it "sets :profile_examples to false" do
-      expect(parse_options('--no-profile')).to include(:profile_examples => false)
-    end
-  end
-
-  describe '--line_number' do
-    it "sets :line_number" do
-      expect(parse_options('-l','3')).to include(:line_numbers => ['3'])
-      expect(parse_options('--line_number','3')).to include(:line_numbers => ['3'])
-    end
-
-    it "can be specified multiple times" do
-      expect(parse_options('-l','3', '-l', '6')).to include(:line_numbers => ['3', '6'])
-      expect(parse_options('--line_number','3', '--line_number', '6')).to include(:line_numbers => ['3', '6'])
-    end
-  end
-
-  describe "--example" do
-    it "sets :full_description" do
-      expect(parse_options('--example','foo')).to include(:full_description => [/foo/])
-      expect(parse_options('-e','bar')).to include(:full_description => [/bar/])
-    end
-  end
-
-  describe "--backtrace, -b" do
-    it "sets full_backtrace on config" do
-      expect(parse_options("--backtrace")).to include(:full_backtrace => true)
-      expect(parse_options("-b")).to include(:full_backtrace => true)
-    end
-  end
-
-  describe "--fail-fast" do
-    it "defaults to false" do
-      expect(parse_options[:fail_fast]).to be_falsey
-    end
-
-    it "sets fail_fast on config" do
-      expect(parse_options("--fail-fast")[:fail_fast]).to be_truthy
-    end
-
-    it "sets fail_fast on config" do
-      expect(parse_options("--no-fail-fast")[:fail_fast]).to be_falsey
-    end
-  end
-
-  describe "--failure-exit-code" do
-    it "sets :failure_exit_code" do
-      expect(parse_options('--failure-exit-code', '0')).to include(:failure_exit_code => 0)
-      expect(parse_options('--failure-exit-code', '1')).to include(:failure_exit_code => 1)
-      expect(parse_options('--failure-exit-code', '2')).to include(:failure_exit_code => 2)
-    end
-
-    it "overrides previous :failure_exit_code" do
-      expect(parse_options('--failure-exit-code', '2', '--failure-exit-code', '3')).to include(:failure_exit_code => 3)
-    end
-  end
-
-  describe "--dry-run" do
-    it "defaults to false" do
-      expect(parse_options[:dry_run]).to be_falsey
-    end
-
-    it "sets dry_run on config" do
-      expect(parse_options("--dry-run")[:dry_run]).to be_truthy
-    end
-  end
-
-  describe "--options" do
-    it "sets :custom_options_file" do
-      expect(parse_options(*%w[-O my.opts])).to include(:custom_options_file => "my.opts")
-      expect(parse_options(*%w[--options my.opts])).to include(:custom_options_file => "my.opts")
-    end
-  end
-
-  describe "--drb, -X" do
-    it "does not send --drb back to the parser after parsing options" do
-      expect(config_options_object("--drb", "--color").drb_argv).not_to include("--drb")
-    end
-  end
-
-  describe "--no-drb" do
-    it "disables drb" do
-      expect(parse_options("--no-drb")).to include(:drb => false)
-    end
-
-    it "overrides a previous drb => true" do
-      expect(parse_options("--drb", "--no-drb")).to include(:drb => false)
-    end
-
-    it "gets overriden by a subsquent drb => true" do
-      expect(parse_options("--no-drb", "--drb")).to include(:drb => true)
-    end
-  end
-
-
-  describe "files_or_directories_to_run" do
-    it "parses files from '-c file.rb dir/file.rb'" do
-      expect(parse_options("-c", "file.rb", "dir/file.rb")).to include(
-        :files_or_directories_to_run => ["file.rb", "dir/file.rb"]
-      )
-    end
-
-    it "parses dir from 'dir'" do
-      expect(parse_options("dir")).to include(:files_or_directories_to_run => ["dir"])
-    end
-
-    it "parses dir and files from 'spec/file1_spec.rb, spec/file2_spec.rb'" do
-      expect(parse_options("dir", "spec/file1_spec.rb", "spec/file2_spec.rb")).to include(
-        :files_or_directories_to_run => ["dir", "spec/file1_spec.rb", "spec/file2_spec.rb"]
-      )
-    end
-
-    it "parses file names that look like options line-number and default-path" do
-      expect(parse_options("spec/default_path_spec.rb", "spec/line_number_spec.rb")).to include(
-        :files_or_directories_to_run => ["spec/default_path_spec.rb", "spec/line_number_spec.rb"]
-      )
-    end
-
-    it "provides no files or directories if spec directory does not exist" do
-      allow(FileTest).to receive(:directory?).with("spec").and_return false
-      expect(parse_options()).to include(:files_or_directories_to_run => [])
-    end
-  end
-
-  describe "default_path" do
-    it "gets set before files_or_directories_to_run" do
-      config = RSpec::Core::Configuration.new
-      expect(config).to receive(:force).with(:default_path => 'foo').ordered
-      expect(config).to receive(:get_files_to_run).ordered
-      opts = config_options_object("--default_path", "foo")
-      opts.configure(config)
-      config.files_to_run
-    end
-  end
-
-  describe "#filter_manager" do
-    it "returns the same object as RSpec::configuration.filter_manager" do
-      expect(config_options_object.filter_manager).to be(RSpec::configuration.filter_manager)
-    end
-  end
-
-  describe "sources: ~/.rspec, ./.rspec, ./.rspec-local, custom, CLI, and SPEC_OPTS" do
-    it "merges global, local, SPEC_OPTS, and CLI" do
-      File.open("./.rspec", "w") {|f| f << "--line 37"}
-      File.open("./.rspec-local", "w") {|f| f << "--format global"}
-      File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--color"}
-      with_env_vars 'SPEC_OPTS' => "--example 'foo bar'" do
-        options = parse_options("--drb")
-        expect(options[:color]).to be_truthy
-        expect(options[:line_numbers]).to eq(["37"])
-        expect(options[:full_description]).to eq([/foo\ bar/])
-        expect(options[:drb]).to be_truthy
-        expect(options[:formatters]).to eq([['global']])
-      end
-    end
-
-    it "prefers SPEC_OPTS over CLI" do
-      with_env_vars 'SPEC_OPTS' => "--format spec_opts" do
-        expect(parse_options("--format", "cli")[:formatters]).to eq([['spec_opts']])
-      end
-    end
-
-    it "prefers CLI over file options" do
-      File.open("./.rspec", "w") {|f| f << "--format project"}
-      File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
-      expect(parse_options("--format", "cli")[:formatters]).to eq([['cli']])
-    end
-
-    it "prefers project file options over global file options" do
-      File.open("./.rspec", "w") {|f| f << "--format project"}
-      File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
-      expect(parse_options[:formatters]).to eq([['project']])
-    end
-
-    it "prefers local file options over project file options" do
-      File.open("./.rspec-local", "w") {|f| f << "--format local"}
-      File.open("./.rspec", "w") {|f| f << "--format global"}
-      expect(parse_options[:formatters]).to eq([['local']])
-    end
-
-    it "parses options file correctly if erb code has trimming options" do
-      File.open("./.rspec", "w") do |f|
-        f << "<% if true -%>\n"
-        f << "--format local\n"
-        f << "<%- end %>\n"
-      end
-
-      expect(parse_options[:formatters]).to eq([['local']])
-    end
-
-    context "with custom options file" do
-      it "ignores project and global options files" do
-        File.open("./.rspec", "w") {|f| f << "--format project"}
-        File.open(File.expand_path("~/.rspec"), "w") {|f| f << "--format global"}
-        File.open("./custom.opts", "w") {|f| f << "--color"}
-        options = parse_options("-O", "./custom.opts")
-        expect(options[:format]).to be_nil
-        expect(options[:color]).to be_truthy
-      end
-
-      it "parses -e 'full spec description'" do
-        File.open("./custom.opts", "w") {|f| f << "-e 'The quick brown fox jumps over the lazy dog'"}
-        options = parse_options("-O", "./custom.opts")
-        expect(options[:full_description]).to eq([/The\ quick\ brown\ fox\ jumps\ over\ the\ lazy\ dog/])
-      end
-    end
-  end
-end