cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/cli/main_spec.rb

@@ -1,14 +1,13 @@
 require 'spec_helper'
 require 'yaml'
-require 'cucumber/parser/gherkin_builder'
 require 'gherkin/formatter/model'
 
 module Cucumber
   module Cli
     describe Main do
       before(:each) do
-        File.stub(:exist?).and_return(false) # When Configuration checks for cucumber.yml
-        Dir.stub(:[]).and_return([]) # to prevent cucumber's features dir to being laoded
+        allow(File).to receive(:exist?) { false } # When Configuration checks for cucumber.yml
+        allow(Dir).to receive(:[]) { [] } # to prevent cucumber's features dir to being laoded
       end
 
       let(:args)   { [] }
@@ -27,18 +26,22 @@ module Cucumber
           end
 
           it "configures that runtime" do
-            expected_configuration = double('Configuration', :drb? => false).as_null_object
-            Configuration.stub(:new => expected_configuration)
-            existing_runtime.should_receive(:configure).with(expected_configuration)
-            kernel.should_receive(:exit).with(1)
+            expected_configuration = double('Configuration').as_null_object
+
+            allow(Configuration).to receive(:new) { expected_configuration }
+            expect(existing_runtime).to receive(:configure).with(expected_configuration)
+            expect(kernel).to receive(:exit).with(1)
+
             do_execute
           end
 
           it "uses that runtime for running and reporting results" do
             expected_results = double('results', :failure? => true)
-            existing_runtime.should_receive(:run!)
-            existing_runtime.stub(:results).and_return(expected_results)
-            kernel.should_receive(:exit).with(1)
+
+            expect(existing_runtime).to receive(:run!)
+            allow(existing_runtime).to receive(:results) { expected_results }
+            expect(kernel).to receive(:exit).with(1)
+
             do_execute
           end
         end
@@ -48,119 +51,53 @@ module Cucumber
             Cucumber.wants_to_quit = false
           end
 
-          it "should register as a failure" do
+          it "registers as a failure" do
             results = double('results', :failure? => false)
-            runtime = Runtime.any_instance
-            runtime.stub(:run!)
-            runtime.stub(:results).and_return(results)
-
-            Cucumber.wants_to_quit = true
-            kernel.should_receive(:exit).with(1)
-            subject.execute!
-          end
-        end
-      end
 
-      describe "verbose mode" do
+            allow_any_instance_of(Runtime).to receive(:run!)
+            allow_any_instance_of(Runtime).to receive(:results) { results }
 
-        before(:each) do
-          b = Cucumber::Parser::GherkinBuilder.new('features/foo.feature')
-          b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99, ""))
-          b.language = double
-          @empty_feature = b.result
-        end
-
-        it "should show feature files parsed" do
-          cli = Main.new(%w{--verbose example.feature}, stdin, stdout, stderr, kernel)
-          cli.stub(:require)
-
-          Cucumber::FeatureFile.stub(:new).and_return(double("feature file", :parse => @empty_feature))
+            Cucumber.wants_to_quit = true
 
-          kernel.should_receive(:exit).with(0)
-          cli.execute!
+            expect(kernel).to receive(:exit).with(1)
 
-          stdout.string.should include('example.feature')
+            subject.execute!
+          end
         end
-
       end
 
       describe "--format with class" do
         describe "in module" do
-          it "should resolve each module until it gets Formatter class" do
+          let(:double_module) { double('module') }
+          let(:formatter) { double('formatter') }
+
+          it "resolves each module until it gets Formatter class" do
             cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, stdin, stdout, stderr, kernel)
-            double = double('module')
-            Object.stub(:const_defined?).and_return(true)
-            double.stub(:const_defined?).and_return(true)
 
-            f = double('formatter').as_null_object
+            allow(Object).to receive(:const_defined?) { true }
+            allow(double_module).to receive(:const_defined?) { true }
+
+            expect(Object).to receive(:const_get).with('ZooModule', false) { double_module }
+            expect(double_module).to receive(:const_get).with('MonkeyFormatterClass', false) { double('formatter class', :new => formatter) }
 
-            if Cucumber::RUBY_1_8_7
-              Object.should_receive(:const_get).with('ZooModule').and_return(double)
-              double.should_receive(:const_get).with('MonkeyFormatterClass').and_return(double('formatter class', :new => f))
-            else
-              Object.should_receive(:const_get).with('ZooModule', false).and_return(double)
-              double.should_receive(:const_get).with('MonkeyFormatterClass', false).and_return(double('formatter class', :new => f))
-            end
+            expect(kernel).to receive(:exit).with(0)
 
-            kernel.should_receive(:exit).with(0)
             cli.execute!
           end
         end
       end
 
       [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
-
         it "rescues #{exception_klass}, prints the message to the error stream" do
-          Configuration.stub(:new).and_return(configuration = double('configuration'))
-          configuration.stub(:parse!).and_raise(exception_klass.new("error message"))
-
-          subject.execute!
-          stderr.string.should == "error message\n"
-        end
-      end
+          configuration = double('configuration')
 
-      context "--drb" do
-        before(:each) do
-          @configuration = double('Configuration', :drb? => true, :dotcucumber => false).as_null_object
-          Configuration.stub(:new).and_return(@configuration)
+          allow(Configuration).to receive(:new) { configuration }
+          allow(configuration).to receive(:parse!).and_raise(exception_klass.new("error message"))
+          allow(kernel).to receive(:exit).with(1)
 
-          args = ['features']
-
-          step_mother = double('StepMother').as_null_object
-          StepMother.stub(:new).and_return(step_mother)
-
-          @cli = Main.new(args, stdin, stdout, stderr, kernel)
-        end
-
-        it "delegates the execution to the DRB client passing the args and streams" do
-          @configuration.stub :drb_port => 1450
-          DRbClient.should_receive(:run) do
-            kernel.exit(1)
-          end
-          kernel.should_receive(:exit).with(1)
-          @cli.execute!
-        end
-
-        it "returns the result from the DRbClient" do
-          DRbClient.stub(:run).and_return('foo')
-          @cli.execute!.should == 'foo'
-        end
-
-        it "ceases execution if the DrbClient is able to perform the execution" do
-          DRbClient.stub(:run).and_return(true)
-          @configuration.should_not_receive(:build_formatter_broadcaster)
-          @cli.execute!
-        end
-
-        context "when the DrbClient is unable to perfrom the execution" do
-          before { DRbClient.stub(:run).and_raise(DRbClientError.new('error message.')) }
-
-          it "alerts the user that execution will be performed locally" do
-            kernel.should_receive(:exit).with(1)
-            @cli.execute!
-            stderr.string.should include("WARNING: error message. Running features locally:")
-          end
+          subject.execute!
 
+          expect(stderr.string).to eq "error message\n"
         end
       end
     end

data/spec/cucumber/cli/options_spec.rb

@@ -3,367 +3,333 @@ require 'yaml'
 require 'cucumber/cli/options'
 
 module Cucumber
-module Cli
-  describe Options do
+  module Cli
+    describe Options do
 
-    def given_cucumber_yml_defined_as(hash_or_string)
-      File.stub(:exist?).and_return(true)
-      cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
-      IO.stub(:read).with('cucumber.yml').and_return(cucumber_yml)
-    end
-
-    before(:each) do
-      File.stub(:exist?).and_return(false) # Meaning, no cucumber.yml exists
-      Kernel.stub(:exit).and_return(nil)
-    end
+      def given_cucumber_yml_defined_as(hash_or_string)
+        allow(File).to receive(:exist?) { true }
 
-    def output_stream
-      @output_stream ||= StringIO.new
-    end
+        cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
 
-    def error_stream
-      @error_stream ||= StringIO.new
-    end
+        allow(IO).to receive(:read).with('cucumber.yml') { cucumber_yml }
+      end
 
-    def options
-      @options ||= Options.new(output_stream, error_stream)
-    end
+      before(:each) do
+        allow(File).to receive(:exist?) { false } # Meaning, no cucumber.yml exists
+        allow(Kernel).to receive(:exit)
+      end
 
-    def prepare_args(args)
-      args.is_a?(Array) ? args : args.split(' ')
-    end
+      def output_stream
+        @output_stream ||= StringIO.new
+      end
 
-    describe 'parsing' do
+      def error_stream
+        @error_stream ||= StringIO.new
+      end
 
-      def when_parsing(args)
-        yield
-        options.parse!(prepare_args(args))
+      def options
+        @options ||= Options.new(output_stream, error_stream)
       end
 
-      def after_parsing(args)
-        options.parse!(prepare_args(args))
-        yield
+      def prepare_args(args)
+        args.is_a?(Array) ? args : args.split(' ')
       end
 
-      context '-r or --require' do
-        it "collects all specified files into an array" do
-          after_parsing('--require some_file.rb -r another_file.rb') do
-            options[:require].should == ['some_file.rb', 'another_file.rb']
-          end
+      describe 'parsing' do
+
+        def when_parsing(args)
+          yield
+          options.parse!(prepare_args(args))
         end
-      end
 
-      context '--i18n' do
-        context "with LANG specified as 'help'" do
-          include RSpec::WorkInProgress
+        def after_parsing(args)
+          options.parse!(prepare_args(args))
+          yield
+        end
 
-          it "lists all known langues" do
-            when_parsing '--i18n help' do
-              Kernel.should_receive(:exit)
+        context '-r or --require' do
+          it "collects all specified files into an array" do
+            after_parsing('--require some_file.rb -r another_file.rb') do
+              expect(options[:require]).to eq ['some_file.rb', 'another_file.rb']
             end
           end
+        end
 
-          it "exits the program" do
-            when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+        context '--i18n' do
+          context "with LANG specified as 'help'" do
+            include RSpec::WorkInProgress
+
+            it "lists all known langues" do
+              when_parsing '--i18n help' do
+                expect(Kernel).to receive(:exit)
+              end
+            end
+
+            it "exits the program" do
+              when_parsing('--i18n help') { expect(Kernel).to receive(:exit) }
+            end
           end
         end
-      end
 
-      context "--port PORT" do
-        it "sets the drb_port to the provided option" do
-          after_parsing('--port 4500') { options[:drb_port].should == '4500' }
+        context '-f FORMAT or --format FORMAT' do
+          it "defaults the output for the formatter to the output stream (STDOUT)" do
+            after_parsing('-f pretty') { expect(options[:formats]).to eq [['pretty', output_stream]] }
+          end
         end
-      end
 
-      context '-f FORMAT or --format FORMAT' do
-        it "defaults the output for the formatter to the output stream (STDOUT)" do
-          after_parsing('-f pretty') { options[:formats].should == [['pretty', output_stream]] }
+        context '-o [FILE|DIR] or --out [FILE|DIR]' do
+          it "defaults the formatter to 'pretty' when not specified earlier" do
+            after_parsing('-o file.txt') { expect(options[:formats]).to eq [['pretty', 'file.txt']] }
+          end
+          it "sets the output for the formatter defined immediatly before it" do
+            after_parsing('-f profile --out file.txt -f pretty -o file2.txt') do
+              expect(options[:formats]).to eq [['profile', 'file.txt'], ['pretty', 'file2.txt']]
+            end
+          end
         end
-      end
 
-      context '-o [FILE|DIR] or --out [FILE|DIR]' do
-        it "defaults the formatter to 'pretty' when not specified earlier" do
-          after_parsing('-o file.txt') { options[:formats].should == [['pretty', 'file.txt']] }
-        end
-        it "sets the output for the formatter defined immediatly before it" do
-          after_parsing('-f profile --out file.txt -f pretty -o file2.txt') do
-            options[:formats].should == [['profile', 'file.txt'], ['pretty', 'file2.txt']]
+        context '-t TAGS --tags TAGS' do
+          it "designates tags prefixed with ~ as tags to be excluded" do
+            after_parsing('--tags ~@foo,@bar') { expect(options[:tag_expressions]).to eq ['~@foo,@bar'] }
           end
-        end
-      end
 
-      context '-t TAGS --tags TAGS' do
-        it "designates tags prefixed with ~ as tags to be excluded" do
-          after_parsing('--tags ~@foo,@bar') { options[:tag_expressions].should == ['~@foo,@bar'] }
+          it "stores tags passed with different --tags seperately" do
+            after_parsing('--tags @foo --tags @bar') { expect(options[:tag_expressions]).to eq ['@foo', '@bar'] }
+          end
         end
 
-        it "stores tags passed with different --tags seperately" do
-          after_parsing('--tags @foo --tags @bar') { options[:tag_expressions].should == ['@foo', '@bar'] }
+        context '-n NAME or --name NAME' do
+          it "stores the provided names as regular expressions" do
+            after_parsing('-n foo --name bar') { expect(options[:name_regexps]).to eq [/foo/,/bar/] }
+          end
         end
-      end
 
-      context '-n NAME or --name NAME' do
-        it "stores the provided names as regular expressions" do
-          after_parsing('-n foo --name bar') { options[:name_regexps].should == [/foo/,/bar/] }
+        context '-e PATTERN or --exclude PATTERN' do
+          it "stores the provided exclusions as regular expressions" do
+            after_parsing('-e foo --exclude bar') { expect(options[:excludes]).to eq [/foo/,/bar/] }
+          end
         end
-      end
 
-      context '-e PATTERN or --exclude PATTERN' do
-        it "stores the provided exclusions as regular expressions" do
-          after_parsing('-e foo --exclude bar') { options[:excludes].should == [/foo/,/bar/] }
-        end
-      end
+        context '-l LINES or --lines LINES' do
+          it "adds line numbers to args" do
+            options.parse!(%w{-l24 FILE})
 
-      context '-l LINES or --lines LINES' do
-        it "adds line numbers to args" do
-          options.parse!(%w{-l24 FILE})
-          options.instance_variable_get(:@args).should == ['FILE:24']
+            expect(options.instance_variable_get(:@args)).to eq ['FILE:24']
+          end
         end
-      end
 
-      context '-p PROFILE or --profile PROFILE' do
+        context '-p PROFILE or --profile PROFILE' do
+          it "uses the default profile passed in during initialization if none are specified by the user" do
+            given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
-        it "uses the default profile passed in during initialization if none are specified by the user" do
-          given_cucumber_yml_defined_as({'default' => '--require some_file'})
+            options = Options.new(output_stream, error_stream, :default_profile => 'default')
+            options.parse!(%w{--format progress})
 
-          options = Options.new(output_stream, error_stream, :default_profile => 'default')
-          options.parse!(%w{--format progress})
-          options[:require].should include('some_file')
-        end
+            expect(options[:require]).to include('some_file')
+          end
 
-        it "merges all uniq values from both cmd line and the profile" do
-          given_cucumber_yml_defined_as('foo' => %w[--verbose])
-          options.parse!(%w[--wip --profile foo])
-          options[:wip].should be_true
-          options[:verbose].should be_true
-        end
+          it "merges all uniq values from both cmd line and the profile" do
+            given_cucumber_yml_defined_as('foo' => %w[--verbose])
+            options.parse!(%w[--wip --profile foo])
 
-        it "gives precendene to the origianl options' paths" do
-          given_cucumber_yml_defined_as('foo' => %w[features])
-          options.parse!(%w[my.feature -p foo])
-          options[:paths].should == %w[my.feature]
-        end
+            expect(options[:wip]).to be true
+            expect(options[:verbose]).to be true
+          end
 
-        it "combines the require files of both" do
-          given_cucumber_yml_defined_as('bar' => %w[--require features -r dog.rb])
-          options.parse!(%w[--require foo.rb -p bar])
-          options[:require].should == %w[foo.rb features dog.rb]
-        end
+          it "gives precendene to the origianl options' paths" do
+            given_cucumber_yml_defined_as('foo' => %w[features])
+            options.parse!(%w[my.feature -p foo])
 
-        it "combines the tag names of both" do
-          given_cucumber_yml_defined_as('baz' => %w[-t @bar])
-          options.parse!(%w[--tags @foo -p baz])
-          options[:tag_expressions].should == ["@foo", "@bar"]
-        end
+            expect(options[:paths]).to eq %w[my.feature]
+          end
 
-        it "only takes the paths from the original options, and disgregards the profiles" do
-          given_cucumber_yml_defined_as('baz' => %w[features])
-          options.parse!(%w[my.feature -p baz])
-          options[:paths].should == ['my.feature']
-        end
+          it "combines the require files of both" do
+            given_cucumber_yml_defined_as('bar' => %w[--require features -r dog.rb])
+            options.parse!(%w[--require foo.rb -p bar])
 
-        it "uses the paths from the profile when none are specified originally" do
-          given_cucumber_yml_defined_as('baz' => %w[some.feature])
-          options.parse!(%w[-p baz])
-          options[:paths].should == ['some.feature']
-        end
+            expect(options[:require]).to eq %w[foo.rb features dog.rb]
+          end
 
-        it "combines environment variables from the profile but gives precendene to cmd line args" do
-          given_cucumber_yml_defined_as('baz' => %w[FOO=bar CHEESE=swiss])
-          options.parse!(%w[-p baz CHEESE=cheddar BAR=foo])
-          options[:env_vars].should == {'BAR' => 'foo', 'FOO' => 'bar', 'CHEESE' => 'cheddar'}
-        end
+          it "combines the tag names of both" do
+            given_cucumber_yml_defined_as('baz' => %w[-t @bar])
+            options.parse!(%w[--tags @foo -p baz])
 
-        it "disregards STDOUT formatter defined in profile when another is passed in (via cmd line)" do
-          given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
-          options.parse!(%w{--format progress --profile foo})
-          options[:formats].should == [['progress', output_stream]]
-        end
+            expect(options[:tag_expressions]).to eq ["@foo", "@bar"]
+          end
 
-        it "includes any non-STDOUT formatters from the profile" do
-          given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html]})
-          options.parse!(%w{--format progress --profile html})
-          options[:formats].should == [['progress', output_stream], ['html', 'features.html']]
-        end
+          it "only takes the paths from the original options, and disgregards the profiles" do
+            given_cucumber_yml_defined_as('baz' => %w[features])
+            options.parse!(%w[my.feature -p baz])
 
-        it "does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line" do
-          given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html --format pretty]})
-          options.parse!(%w{--format progress --profile html})
-          options[:formats].should == [['progress', output_stream], ['html', 'features.html']]
-        end
+            expect(options[:paths]).to eq ['my.feature']
+          end
 
-        it "includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line" do
-          given_cucumber_yml_defined_as({'html' => %w[--format html]})
-          options.parse!(%w{--format rerun -o rerun.txt --profile html})
-          options[:formats].should == [['html', output_stream], ['rerun', 'rerun.txt']]
-        end
+          it "uses the paths from the profile when none are specified originally" do
+            given_cucumber_yml_defined_as('baz' => %w[some.feature])
+            options.parse!(%w[-p baz])
 
-        it "assumes all of the formatters defined in the profile when none are specified on cmd line" do
-          given_cucumber_yml_defined_as({'html' => %w[--format progress --format html -o features.html]})
-          options.parse!(%w{--profile html})
-          options[:formats].should == [['progress', output_stream], ['html', 'features.html']]
-        end
+            expect(options[:paths]).to eq ['some.feature']
+          end
 
-        it "only reads cucumber.yml once" do
-          original_parse_count = $cucumber_yml_read_count
-          $cucumber_yml_read_count = 0
+          it "combines environment variables from the profile but gives precendene to cmd line args" do
+            given_cucumber_yml_defined_as('baz' => %w[FOO=bar CHEESE=swiss])
+            options.parse!(%w[-p baz CHEESE=cheddar BAR=foo])
 
-          begin
-            given_cucumber_yml_defined_as(<<-END
-            <% $cucumber_yml_read_count += 1 %>
-            default: --format pretty
-            END
-            )
-            options = Options.new(output_stream, error_stream, :default_profile => 'default')
-            options.parse!(%w(-f progress))
-
-            $cucumber_yml_read_count.should == 1
-          ensure
-            $cucumber_yml_read_count = original_parse_count
+            expect(options[:env_vars]).to eq({ 'BAR' => 'foo', 'FOO' => 'bar', 'CHEESE' => 'cheddar' })
           end
-        end
 
-        it "respects --quiet when defined in the profile" do
-          given_cucumber_yml_defined_as('foo' => '-q')
-          options.parse!(%w[-p foo])
-          options[:snippets].should be_false
-          options[:source].should be_false
-        end
-      end
+          it "disregards STDOUT formatter defined in profile when another is passed in (via cmd line)" do
+            given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
+            options.parse!(%w{--format progress --profile foo})
 
-      context '-P or --no-profile' do
+            expect(options[:formats]).to eq [['progress', output_stream]]
+          end
 
-        it "disables profiles" do
-          given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
+          it "includes any non-STDOUT formatters from the profile" do
+            given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html]})
+            options.parse!(%w{--format progress --profile html})
 
-          after_parsing("-P --require some_file.rb") do
-            options[:require].should == ['some_file.rb']
+            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
           end
-        end
 
-        it "notifies the user that the profiles are being disabled" do
-          given_cucumber_yml_defined_as({'default' => '-v'})
+          it "does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line" do
+            given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html --format pretty]})
+            options.parse!(%w{--format progress --profile html})
 
-          after_parsing("--no-profile --require some_file.rb") do
-            output_stream.string.should =~ /Disabling profiles.../
+            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
           end
-        end
 
-      end
+          it "includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line" do
+            given_cucumber_yml_defined_as({'html' => %w[--format html]})
+            options.parse!(%w{--format rerun -o rerun.txt --profile html})
 
-      context '-b or --backtrace' do
-        it "turns on cucumber's full backtrace" do
-          when_parsing("-b") do
-            Cucumber.should_receive(:use_full_backtrace=).with(true)
+            expect(options[:formats]).to eq [['html', output_stream], ['rerun', 'rerun.txt']]
           end
-        end
-      end
 
-      context '--version' do
-        it "displays Cucumber's version" do
-          after_parsing('--version') do
-            output_stream.string.should =~ /#{Cucumber::VERSION}/
+          it "assumes all of the formatters defined in the profile when none are specified on cmd line" do
+            given_cucumber_yml_defined_as({'html' => %w[--format progress --format html -o features.html]})
+            options.parse!(%w{--profile html})
+
+            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
           end
-        end
-        it "exits the program" do
-          when_parsing('--version') { Kernel.should_receive(:exit) }
-        end
-      end
 
-      context 'environment variables (i.e. MODE=webrat)' do
-        it "places all of the environment variables into a hash" do
-          after_parsing('MODE=webrat FOO=bar') do
-            options[:env_vars].should == {'MODE' => 'webrat', 'FOO' => 'bar'}
+          it "only reads cucumber.yml once" do
+            original_parse_count = $cucumber_yml_read_count
+            $cucumber_yml_read_count = 0
+
+            begin
+              given_cucumber_yml_defined_as(<<-END
+              <% $cucumber_yml_read_count += 1 %>
+              default: --format pretty
+              END
+              )
+              options = Options.new(output_stream, error_stream, :default_profile => 'default')
+              options.parse!(%w(-f progress))
+
+              expect($cucumber_yml_read_count).to eq 1
+            ensure
+              $cucumber_yml_read_count = original_parse_count
+            end
           end
-        end
-      end
 
-      it "assigns any extra arguments as paths to features" do
-        after_parsing('-f pretty my_feature.feature my_other_features') do
-          options[:paths].should == ['my_feature.feature', 'my_other_features']
-        end
-      end
+          it "respects --quiet when defined in the profile" do
+            given_cucumber_yml_defined_as('foo' => '-q')
+            options.parse!(%w[-p foo])
 
-      it "does not mistake environment variables as feature paths" do
-        after_parsing('my_feature.feature FOO=bar') do
-          options[:paths].should == ['my_feature.feature']
+            expect(options[:snippets]).to be false
+            expect(options[:source]).to be false
+          end
         end
-      end
 
-      context '--snippet-type' do
-        it "parses the snippet type argument" do
-          after_parsing('--snippet-type classic') do
-            options[:snippet_type].should eql :classic
+        context '-P or --no-profile' do
+          it "disables profiles" do
+            given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
+
+            after_parsing("-P --require some_file.rb") do
+              expect(options[:require]).to eq ['some_file.rb']
+            end
           end
-        end
-      end
 
-    end
+          it "notifies the user that the profiles are being disabled" do
+            given_cucumber_yml_defined_as({'default' => '-v'})
 
-    describe '#expanded_args_without_drb' do
-      it "returns the orginal args in additon to the args from any profiles" do
-        given_cucumber_yml_defined_as('foo' => '-v',
-                                      'bar' => '--wip -p baz',
-                                      'baz' => '-r some_file.rb')
-        options.parse!(%w[features -p foo --profile bar])
+            after_parsing("--no-profile --require some_file.rb") do
+              expect(output_stream.string).to match(/Disabling profiles.../)
+            end
+          end
+        end
 
-        options.expanded_args_without_drb.should == %w[features -v --wip -r some_file.rb --no-profile]
-      end
+        context '-b or --backtrace' do
+          it "turns on cucumber's full backtrace" do
+            when_parsing("-b") do
+              expect(Cucumber).to receive(:use_full_backtrace=).with(true)
+            end
+          end
+        end
 
-      it "removes the --drb flag so that the args can be safely passed to the drb server" do
-        given_cucumber_yml_defined_as('default' => 'features -f pretty --drb')
-        options.parse!(%w[--profile default])
+        context '--version' do
+          it "displays Cucumber's version" do
+            after_parsing('--version') do
+              expect(output_stream.string).to match(/#{Cucumber::VERSION}/)
+            end
+          end
 
-        options.expanded_args_without_drb.should == %w[features -f pretty --no-profile]
-      end
+          it "exits the program" do
+            when_parsing('--version') { expect(Kernel).to receive(:exit) }
+          end
+        end
 
-      it "contains the environment variables" do
-        options.parse!(%w[features FOO=bar])
-        options.expanded_args_without_drb.should == %w[features FOO=bar --no-profile]
-      end
+        context 'environment variables (i.e. MODE=webrat)' do
+          it "places all of the environment variables into a hash" do
+            after_parsing('MODE=webrat FOO=bar') do
+              expect(options[:env_vars]).to eq({ 'MODE' => 'webrat', 'FOO' => 'bar' })
+            end
+          end
+        end
 
-      it "ignores the paths from the profiles if one was specified on the command line" do
-        given_cucumber_yml_defined_as('foo' => 'features --drb')
-        options.parse!(%w[some_feature.feature -p foo])
-        options.expanded_args_without_drb.should == %w[some_feature.feature --no-profile]
-      end
+        it "assigns any extra arguments as paths to features" do
+          after_parsing('-f pretty my_feature.feature my_other_features') do
+            expect(options[:paths]).to eq ['my_feature.feature', 'my_other_features']
+          end
+        end
 
+        it "does not mistake environment variables as feature paths" do
+          after_parsing('my_feature.feature FOO=bar') do
+            expect(options[:paths]).to eq ['my_feature.feature']
+          end
+        end
 
-      it "appends the --no-profile flag so that the DRb server doesn't reload the profiles" do
-        given_cucumber_yml_defined_as('foo' => 'features --drb')
-        options.parse!(%w[some_feature.feature -p foo])
-        options.expanded_args_without_drb.should == %w[some_feature.feature --no-profile]
+        context '--snippet-type' do
+          it "parses the snippet type argument" do
+            after_parsing('--snippet-type classic') do
+              expect(options[:snippet_type]).to eq :classic
+            end
+          end
+        end
       end
 
-      it "does not append --no-profile if already present" do
-        options.parse!(%w[some_feature.feature -P])
-        options.expanded_args_without_drb.should == %w[some_feature.feature -P]
-      end
+      describe "dry-run" do
+        it "has the default value for snippets" do
+          given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
+          options.parse!(%w{--dry-run})
 
+          expect(options[:snippets]).to be true
+        end
 
-    end
+        it "sets snippets to false when no-snippets provided after dry-run" do
+          given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
+          options.parse!(%w{--dry-run --no-snippets})
 
-    describe "dry-run" do
-      it "should have the default value for snippets" do
-        given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
-        options.parse!(%w{--dry-run})
-        options[:snippets].should == true
-      end
+          expect(options[:snippets]).to be false
+        end
 
-      it "should set snippets to false when no-snippets provided after dry-run" do
-        given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
-        options.parse!(%w{--dry-run --no-snippets})
-        options[:snippets].should == false
-      end
+        it "sets snippets to false when no-snippets provided before dry-run" do
+          given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
+          options.parse!(%w{--no-snippets --dry-run})
 
-      it "should set snippets to false when no-snippets provided before dry-run" do
-        given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
-        options.parse!(%w{--no-snippets --dry-run})
-        options[:snippets].should == false
+          expect(options[:snippets]).to be false
+        end
       end
     end
   end
-
-end
 end
-