js-log-cucumber 1.0.2

data/spec/cucumber/cli/drb_client_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Cucumber
+  module Cli
+    describe DRbClient do
+      before(:each) do
+        @args = ['features']
+        @error_stream = StringIO.new
+        @out_stream = StringIO.new
+
+        @drb_object = mock('DRbObject', :run => true)
+        DRbObject.stub!(:new_with_uri).and_return(@drb_object)
+      end
+
+      it "starts up a druby service" do
+        DRb.should_receive(:start_service).with("druby://localhost:0")
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "connects to the DRb server" do
+        DRbObject.should_receive(:new_with_uri).with("druby://127.0.0.1:8990")
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "runs the features on the DRb server" do
+        @drb_object.should_receive(:run).with(@args, @error_stream, @out_stream)
+        DRbClient.run(@args, @error_stream, @out_stream)
+      end
+
+      it "returns raises an error when it can't connect to the server" do
+        DRbObject.stub!(:new_with_uri).and_raise(DRb::DRbConnError)
+        lambda { DRbClient.run(@args, @error_stream, @out_stream) }.should raise_error(DRbClientError, "No DRb server is running.")
+      end
+
+      it "returns the result from the DRb server call" do
+        @drb_object.should_receive(:run).and_return('foo')
+        DRbClient.run(@args, @error_stream, @out_stream).should == 'foo'
+      end
+
+      context "with $CUCUMBER_DRB set" do
+        before do 
+          @original_env = ENV['CUCUMBER_DRB']
+          ENV['CUCUMBER_DRB'] = '90000'
+        end
+        after do
+          ENV['CUCUMBER_DRB'] = @original_env
+        end
+        it "connects to specified DRb server" do
+          DRbObject.should_receive(:new_with_uri).with("druby://127.0.0.1:90000")
+          DRbClient.run(@args, @error_stream, @out_stream)
+        end
+      end
+
+      context "with provided drb_port" do
+        before do
+          @args = @args + ['--port', '8000']
+        end
+        it "connects to specified drb port" do
+          DRbObject.should_receive(:new_with_uri).with("druby://127.0.0.1:8000")
+          DRbClient.run(@args, @error_stream, @out_stream, 8000)
+        end
+        it "prefers configuration to environment"  do
+          original = ENV['CUCUMBER_DRB'] = original
+          begin
+            ENV['CUCUMBER_DRB'] = "4000"
+            DRbObject.should_receive(:new_with_uri).with("druby://127.0.0.1:8000")
+            DRbClient.run(@args, @error_stream, @out_stream, 8000)
+          ensure
+            ENV['CUCUMBER_DRB'] = original
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/cucumber/cli/main_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'yaml'
+require 'cucumber/parser/gherkin_builder'
+require 'gherkin/formatter/model'
+
+module Cucumber
+  module Cli
+    describe Main do
+      before(:each) do
+        @out = StringIO.new
+        @err = StringIO.new
+        Kernel.stub!(:exit).and_return(nil)
+        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
+      end
+      
+      let(:args)       { [] }
+      let(:out_stream) { nil }
+      let(:err_stream) { nil }
+      subject { Main.new(args, out_stream, err_stream)}
+      
+      describe "#execute!" do
+        context "passed an existing runtime" do
+          let(:existing_runtime) { double('runtime').as_null_object }
+          
+          def do_execute
+            subject.execute!(existing_runtime)
+          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)
+            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)
+            do_execute.should == expected_results.failure?
+          end
+        end
+      end
+
+      describe "verbose mode" do
+
+        before(:each) do
+          b = Cucumber::Parser::GherkinBuilder.new
+          @empty_feature = b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99))
+        end
+
+        it "should show feature files parsed" do
+          @cli = Main.new(%w{--verbose example.feature}, @out)
+          @cli.stub!(:require)
+
+          Cucumber::FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
+
+          @cli.execute!
+
+          @out.string.should include('example.feature')
+        end
+
+      end
+
+      describe "--format with class" do
+        describe "in module" do
+          it "should resolve each module until it gets Formatter class" do
+            cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, nil)
+            mock_module = mock('module')
+            Object.stub!(:const_defined?).and_return(true)
+            mock_module.stub!(:const_defined?).and_return(true)
+
+            f = stub('formatter').as_null_object
+
+            Object.should_receive(:const_get).with('ZooModule').and_return(mock_module)
+            mock_module.should_receive(:const_get).with('MonkeyFormatterClass').and_return(mock('formatter class', :new => f))
+
+            cli.execute!
+          end
+        end
+      end
+
+      [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
+
+        it "rescues #{exception_klass}, prints the message to the error stream and returns true" do
+          Configuration.stub!(:new).and_return(configuration = mock('configuration'))
+          configuration.stub!(:parse!).and_raise(exception_klass.new("error message"))
+
+          main = Main.new('', out = StringIO.new, error = StringIO.new)
+          main.execute!.should be_true
+          error.string.should == "error message\n"
+        end
+      end
+
+      context "--drb" do
+        before(:each) do
+          @configuration = mock('Configuration', :drb? => true).as_null_object
+          Configuration.stub!(:new).and_return(@configuration)
+
+          @args = ['features']
+
+          @cli = Main.new(@args, @out, @err)
+          @step_mother = mock('StepMother').as_null_object
+          StepMother.stub!(:new).and_return(@step_mother)
+        end
+
+        it "delegates the execution to the DRB client passing the args and streams" do
+          @configuration.stub :drb_port => 1450
+          DRbClient.should_receive(:run).with(@args, @err, @out, 1450).and_return(true)
+          @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
+            @cli.execute!
+            @err.string.should include("WARNING: error message. Running features locally:")
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/cli/options_spec.rb

@@ -0,0 +1,358 @@
+require 'spec_helper'
+require 'yaml'
+require 'cucumber/cli/options'
+
+module Cucumber
+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 output_stream
+      @output_stream ||= StringIO.new
+    end
+
+    def error_stream
+      @error_stream ||= StringIO.new
+    end
+
+    def options
+      @options ||= Options.new(output_stream, error_stream)
+    end
+
+    def prepare_args(args)
+      args.is_a?(Array) ? args : args.split(' ')
+    end
+
+    describe 'parsing' do
+
+      def when_parsing(args)
+        yield
+        options.parse!(prepare_args(args))
+      end
+
+      def after_parsing(args)
+        options.parse!(prepare_args(args))
+        yield
+      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
+        end
+      end
+
+      context '--i18n' do
+        context "with LANG specified as 'help'" do
+          it "lists all known langues" do
+            when_parsing '--i18n help' do
+              Kernel.should_receive(:exit)
+            end
+          end
+
+          it "exits the program" do
+            when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+          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' }
+        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]] }
+        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']]
+          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'] }
+        end
+
+        it "stores tags passed with different --tags seperately" do
+          after_parsing('--tags @foo --tags @bar') { options[:tag_expressions].should == ['@foo', '@bar'] }
+        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/] }
+        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})
+          options.instance_variable_get(:@args).should == ['FILE:24']
+        end
+      end
+
+      context '-p PROFILE or --profile PROFILE' do
+
+        it "notifies the user that an individual profile is being used" do
+          given_cucumber_yml_defined_as({'foo' => [1,2,3]})
+          options.parse!(%w{--profile foo})
+          output_stream.string.should =~ /Using the foo profile...\n/
+        end
+
+        it "notifies the user when multiple profiles are being used" do
+          given_cucumber_yml_defined_as({'foo' => [1,2,3], 'bar' => ['v'], 'dog' => ['v']})
+          options.parse!(%w{--profile foo --profile bar --profile dog})
+          output_stream.string.should =~ /Using the foo, bar and dog profiles...\n/
+        end
+
+        it "notifies the user of all profiles being used, even when they are nested" do
+          given_cucumber_yml_defined_as('foo' => '-p bar', 'bar' => 'features')
+          after_parsing('-p foo') do
+            output_stream.string.should =~ /Using the foo and bar profiles.../
+          end
+        end
+
+        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[:require].should 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 "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
+
+        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 "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
+
+        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 "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
+
+        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 "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
+
+        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 "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
+
+        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 "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
+
+        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
+
+      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
+            options[:require].should == ['some_file.rb']
+          end
+        end
+
+        it "notifies the user that the profiles are being disabled" do
+          given_cucumber_yml_defined_as({'default' => '-v'})
+
+          after_parsing("--no-profile --require some_file.rb") do
+            output_stream.string.should =~ /Disabling profiles.../
+          end
+        end
+
+      end
+
+      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)
+          end
+        end
+      end
+
+      context '--version' do
+        it "displays Cucumber's version" do
+          after_parsing('--version') do
+            output_stream.string.should =~ /#{Cucumber::VERSION}/
+          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'}
+          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 "does not mistake environment variables as feature paths" do
+        after_parsing('my_feature.feature FOO=bar') do
+          options[:paths].should == ['my_feature.feature']
+        end
+      end
+    end
+
+    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])
+
+        options.expanded_args_without_drb.should == %w[features -v --wip -r some_file.rb --no-profile]
+      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])
+
+        options.expanded_args_without_drb.should == %w[features -f pretty --no-profile]
+      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
+
+      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 "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]
+      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
+
+
+    end
+
+    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
+
+      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 "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
+      end
+    end
+  end
+
+end
+end
+