cucumber 1.2.5 → 1.3.0

data/spec/cucumber/ast/feature_factory.rb

@@ -26,14 +26,25 @@ module Cucumber
           %w{4444 55555 666666}
         ])
         doc_string = Ast::DocString.new(%{\n I like\nCucumber sandwich\n}, '')
+        location = Ast::Location.new('foo.feature', 2)
+        language = stub.as_null_object
 
-        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "", "",
+        background = Ast::Background.new(
+          language,
+          location,
+          Ast::Comment.new(""), 
+          "Background:", 
+          "", 
+          "",
           [
-            Step.new(3, "Given", "a passing step")
+            Step.new(language, location.on_line(3), "Given", "a passing step")
           ]
         )
 
-        f = Ast::Feature.new(
+        location = Location.new('features/pretty_printing.feature', 0)
+
+        Ast::Feature.new(
+          location,
           background,
           Ast::Comment.new("# My feature comment\n"),
           Ast::Tags.new(6, [Gherkin::Formatter::Model::Tag.new('one', 6), Gherkin::Formatter::Model::Tag.new('two', 6)]),
@@ -41,21 +52,20 @@ module Cucumber
           "Pretty printing",
           "",
           [Ast::Scenario.new(
+            language,
+            location.on_line(9),
             background,
             Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
             Ast::Tags.new(8, [Gherkin::Formatter::Model::Tag.new('three', 8), Gherkin::Formatter::Model::Tag.new('four', 8)]),
-            9,
+            Ast::Tags.new(1, []),
             "Scenario:", "A Scenario", "",
             [
-              Step.new(10, "Given", "a passing step with an inline arg:", table),
-              Step.new(11, "Given", "a happy step with an inline arg:", doc_string),
-              Step.new(12, "Given", "a failing step")
+              Step.new(language, location.on_line(10), "Given", "a passing step with an inline arg:", table),
+              Step.new(language, location.on_line(11), "Given", "a happy step with an inline arg:", doc_string),
+              Step.new(language, location.on_line(12), "Given", "a failing step")
             ]
           )]
         )
-        f.file = 'features/pretty_printing.feature'
-        f.features = Features.new
-        f
       end
     end
   end

data/spec/cucumber/ast/features_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'cucumber/ast/feature_factory'
+
+module Cucumber
+  module Ast
+    describe Features do
+      it "has a step_count" do
+        parse_feature(<<-GHERKIN)
+Feature:
+  Background:
+    Given step 1
+    And step 2
+
+  Scenario:
+    Given step 3
+    And step 4
+    And step 5
+
+  Scenario Outline:
+    Given step <n>
+    And another step
+
+    Examples:
+      | n |
+      | 6 |
+      | 7 |
+
+    Examples:
+      | n |
+      | 8 |
+GHERKIN
+
+        features.step_count.should == (2 + 3) + (3 * (2 + 2))
+      end
+
+      def parse_feature(gherkin)
+        path    = 'features/test.feature'
+        builder = Cucumber::Parser::GherkinBuilder.new(path)
+        parser  = Gherkin::Parser::Parser.new(builder, true, "root", false)
+        parser.parse(gherkin, path, 0)
+        builder.language = parser.i18n_language
+        feature = builder.result
+        features.add_feature(feature)
+      end
+
+      let(:features) { Features.new }
+
+    end
+  end
+end
+

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -26,23 +26,28 @@ module Cucumber
           @eaten.should == n.to_i
         end
 
+        location = Ast::Location.new('foo.feature', 19)
+        language = stub
+
         @scenario_outline = ScenarioOutline.new(
-          background=nil,
+          language,
+          location,
+          background=Ast::EmptyBackground.new,
           Comment.new(""),
           Tags.new(18, []),
-          19,
+          Tags.new(0, []),
           "Scenario:", "My outline", "",
           [
-            Step.new(20, 'Given', 'there are <start> cucumbers'),
-            Step.new(21, 'When',  'I eat <eat> cucumbers'),
-            Step.new(22, 'Then',  'I should have <left> cucumbers'),
-            Step.new(23, 'And',   'I should have <eat> cucumbers in my belly')
+            Step.new(language, location.on_line(20), 'Given', 'there are <start> cucumbers'),
+            Step.new(language, location.on_line(21), 'When',  'I eat <eat> cucumbers'),
+            Step.new(language, location.on_line(22), 'Then',  'I should have <left> cucumbers'),
+            Step.new(language, location.on_line(23), 'And',   'I should have <eat> cucumbers in my belly')
           ],
           [
             [
               [
+                location.on_line(24),
                 Comment.new("#Mmmm... cucumbers\n"),
-                24,
                 'Examples:',
                 'First table',
                 '',
@@ -61,6 +66,7 @@ module Cucumber
       it "should replace all variables and call outline once for each table row" do
         visitor = TreeWalker.new(@step_mother)
         visitor.should_receive(:visit_table_row).exactly(3).times
+        @scenario_outline.feature = stub.as_null_object
         visitor.visit_feature_element(@scenario_outline)
       end
     end

data/spec/cucumber/ast/step_spec.rb

@@ -6,8 +6,10 @@ require 'cucumber/core_ext/string'
 module Cucumber
   module Ast
     describe Step do
+      let(:language) { stub }
+
       it "should replace arguments in name" do
-        step = Step.new(1, 'Given', 'a <color> cucumber')
+        step = Step.new(language, 1, 'Given', 'a <color> cucumber')
 
         invocation_table = Table.new([
           %w{color taste},
@@ -20,7 +22,7 @@ module Cucumber
       end
 
       it "should use empty string for the replacement of arguments in name when replace value is nil" do
-        step = Step.new(1, 'Given', 'a <color>cucumber')
+        step = Step.new(language, 1, 'Given', 'a <color>cucumber')
 
         invocation_table = Table.new([
           ['color'],
@@ -35,7 +37,7 @@ module Cucumber
       it "should replace arguments in table arg" do
         arg_table = Table.new([%w{taste_<taste> color_<color>}])
 
-        step = Step.new(1, 'Given', 'a <color> cucumber', arg_table)
+        step = Step.new(language, 1, 'Given', 'a <color> cucumber', arg_table)
 
         invocation_table = Table.new([
           %w{color taste},
@@ -50,7 +52,7 @@ module Cucumber
       it "should replace arguments in py string arg" do
         doc_string = DocString.new('taste_<taste> color_<color>', '')
 
-        step = Step.new(1, 'Given', 'a <color> cucumber', doc_string)
+        step = Step.new(language, 1, 'Given', 'a <color> cucumber', doc_string)
 
         invocation_table = Table.new([
           %w{color taste},

data/spec/cucumber/cli/configuration_spec.rb

@@ -127,6 +127,7 @@ module Cli
     end
 
     context '--profile' do
+      include RSpec::WorkInProgress
 
       it "expands args from profiles in the cucumber.yml file" do
         given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
@@ -151,7 +152,7 @@ module Cli
       end
 
       it "parses ERB syntax in the cucumber.yml file" do
-        given_cucumber_yml_defined_as 'default' => "<%= '--require some_file' %>"
+        given_cucumber_yml_defined_as("---\ndefault: \"<%=\"--require some_file\"%>\"\n")
 
         config.parse!([])
         config.options[:require].should include('some_file')
@@ -309,6 +310,11 @@ END_OF_MESSAGE
       end.should raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
     end
 
+    it "should accept same --format options with implicit STDOUT, and keep only one" do
+      config.parse!(%w{--format pretty --format pretty})
+      config.formats.should == [["pretty", out]]
+    end
+
     it "should not accept multiple --out streams pointing to the same place" do
       lambda do
         config.parse!(%w{--format pretty --out file1 --format progress --out file1})
@@ -320,6 +326,16 @@ END_OF_MESSAGE
       config.formats.should == [["progress", "file1"], ["profile" ,"file2"]]
     end
 
+    it "should accept same --format options with same --out streams and keep only one" do
+      config.parse!(%w{--format html --out file --format pretty --format html --out file})
+      config.formats.should == [["pretty", out], ["html", "file"]]
+    end
+
+    it "should accept same --format options with different --out streams" do
+      config.parse!(%w{--format html --out file1 --format html --out file2})
+      config.formats.should == [["html", "file1"], ["html", "file2"]]
+    end
+
     it "should accept --color option" do
       Cucumber::Term::ANSIColor.should_receive(:coloring=).with(true)
       config.parse!(['--color'])
@@ -434,6 +450,23 @@ END_OF_MESSAGE
         config.dry_run?.should be_false
       end
     end
+
+    describe "#snippet_type" do
+      it "returns the snippet type when it was set" do
+        config.parse!(["--snippet-type", "classic"])
+        config.snippet_type.should eql :classic
+      end
+
+      it "returns the snippet type when it was set with shorthand option" do
+        config.parse!(["-I", "classic"])
+        config.snippet_type.should eql :classic
+      end
+
+      it "returns the default snippet type if it was not set" do
+        config.parse!([])
+        config.snippet_type.should eql :regexp
+      end
+    end
   end
 end
 end

data/spec/cucumber/cli/main_spec.rb

@@ -7,17 +7,16 @@ 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)}
+      let(:args)   { [] }
+      let(:stdin)  { StringIO.new }
+      let(:stdout) { StringIO.new }
+      let(:stderr) { StringIO.new }
+      let(:kernel) { mock(:kernel) }
+      subject { Main.new(args, stdin, stdout, stderr, kernel)}
 
       describe "#execute!" do
         context "passed an existing runtime" do
@@ -31,6 +30,7 @@ module Cucumber
             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)
             do_execute
           end
 
@@ -38,7 +38,8 @@ module Cucumber
             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?
+            kernel.should_receive(:exit).with(1)
+            do_execute
           end
         end
 
@@ -54,7 +55,8 @@ module Cucumber
             runtime.stub(:results).and_return(results)
 
             Cucumber.wants_to_quit = true
-            subject.execute!.should be_true
+            kernel.should_receive(:exit).with(1)
+            subject.execute!
           end
         end
       end
@@ -62,19 +64,22 @@ module Cucumber
       describe "verbose mode" do
 
         before(:each) do
-          b = Cucumber::Parser::GherkinBuilder.new
-          @empty_feature = b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99, ""))
+          b = Cucumber::Parser::GherkinBuilder.new('features/foo.feature')
+          b.feature(Gherkin::Formatter::Model::Feature.new([], [], "Feature", "Foo", "", 99, ""))
+          b.language = stub
+          @empty_feature = b.result
         end
 
         it "should show feature files parsed" do
-          @cli = Main.new(%w{--verbose example.feature}, @out)
-          @cli.stub!(:require)
+          cli = Main.new(%w{--verbose example.feature}, stdin, stdout, stderr, kernel)
+          cli.stub!(:require)
 
           Cucumber::FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
 
-          @cli.execute!
+          kernel.should_receive(:exit).with(0)
+          cli.execute!
 
-          @out.string.should include('example.feature')
+          stdout.string.should include('example.feature')
         end
 
       end
@@ -82,7 +87,7 @@ module Cucumber
       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)
+            cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, stdin, stdout, stderr, kernel)
             mock_module = mock('module')
             Object.stub!(:const_defined?).and_return(true)
             mock_module.stub!(:const_defined?).and_return(true)
@@ -97,6 +102,7 @@ module Cucumber
               mock_module.should_receive(:const_get).with('MonkeyFormatterClass', false).and_return(mock('formatter class', :new => f))
             end
 
+            kernel.should_receive(:exit).with(0)
             cli.execute!
           end
         end
@@ -104,13 +110,12 @@ module Cucumber
 
       [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
 
-        it "rescues #{exception_klass}, prints the message to the error stream and returns true" do
+        it "rescues #{exception_klass}, prints the message to the error stream" 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"
+          subject.execute!
+          stderr.string.should == "error message\n"
         end
       end
 
@@ -119,16 +124,20 @@ module Cucumber
           @configuration = mock('Configuration', :drb? => true, :dotcucumber => false).as_null_object
           Configuration.stub!(:new).and_return(@configuration)
 
-          @args = ['features']
+          args = ['features']
 
-          @cli = Main.new(@args, @out, @err)
-          @step_mother = mock('StepMother').as_null_object
-          StepMother.stub!(:new).and_return(@step_mother)
+          step_mother = mock('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).with(@args, @err, @out, 1450).and_return(true)
+          DRbClient.should_receive(:run) do
+            kernel.exit(1)
+          end
+          kernel.should_receive(:exit).with(1)
           @cli.execute!
         end
 
@@ -147,8 +156,9 @@ module Cucumber
           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!
-            @err.string.should include("WARNING: error message. Running features locally:")
+            stderr.string.should include("WARNING: error message. Running features locally:")
           end
 
         end

data/spec/cucumber/cli/options_spec.rb

@@ -123,25 +123,6 @@ module Cli
 
       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'})
 
@@ -223,6 +204,25 @@ module Cli
           options[:formats].should == [['progress', output_stream], ['html', 'features.html']]
         end
 
+        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))
+
+            $cucumber_yml_read_count.should == 1
+          ensure
+            $cucumber_yml_read_count = original_parse_count
+          end
+        end
+
         it "respects --quiet when defined in the profile" do
           given_cucumber_yml_defined_as('foo' => '-q')
           options.parse!(%w[-p foo])
@@ -289,6 +289,15 @@ module Cli
           options[:paths].should == ['my_feature.feature']
         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
+          end
+        end
+      end
+
     end
 
     describe '#expanded_args_without_drb' do