cucumber 2.0.0.beta.3 → 2.0.0

data/spec/cucumber/multiline_argument/data_table_spec.rb

@@ -6,7 +6,7 @@ module Cucumber
   module MultilineArgument
     describe DataTable do
       before do
-        @table = DataTable.new([
+        @table = DataTable.from([
           %w{one four seven},
           %w{4444 55555 666666}
         ])
@@ -48,7 +48,7 @@ module Cucumber
         it "applies the block once to each value" do
           headers = ['header']
           rows = ['value']
-          table = DataTable.new [headers, rows]
+          table = DataTable.from [headers, rows]
           count = 0
           table.map_column!('header') { |value| count +=1 }
           table.rows
@@ -94,7 +94,7 @@ module Cucumber
         it "applies the block once to each value" do
           headers = ['header']
           rows = ['value']
-          table = DataTable.new [headers, rows]
+          table = DataTable.from [headers, rows]
           count = 0
           new_table = table.map_column('header') { |value| count +=1 }
           new_table.rows
@@ -133,7 +133,7 @@ module Cucumber
 
       describe "#match" do
         before(:each) do
-          @table = DataTable.new([
+          @table = DataTable.from([
             %w{one four seven},
             %w{4444 55555 666666}
           ])
@@ -152,7 +152,7 @@ module Cucumber
 
       describe "#transpose" do
         before(:each) do
-          @table = DataTable.new([
+          @table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
@@ -166,7 +166,7 @@ module Cucumber
       describe "#rows_hash" do
 
         it "should return a hash of the rows" do
-          table = DataTable.new([
+          table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
@@ -174,7 +174,7 @@ module Cucumber
         end
 
         it "should fail if the table doesn't have two columns" do
-          faulty_table = DataTable.new([
+          faulty_table = DataTable.from([
             %w{one 1111 abc},
             %w{two 22222 def}
           ])
@@ -184,7 +184,7 @@ module Cucumber
         end
 
         it "should support header and column mapping" do
-          table = DataTable.new([
+          table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
@@ -196,7 +196,7 @@ module Cucumber
 
       describe '#map_headers!' do
         let(:table) do
-          DataTable.new([
+          DataTable.from([
           %w{HELLO WORLD},
           %w{4444 55555}
           ])
@@ -236,7 +236,7 @@ module Cucumber
 
       describe '#map_headers' do
         let(:table) do
-           DataTable.new([
+           DataTable.from([
           %w{HELLO WORLD},
           %w{4444 55555}
           ])
@@ -277,20 +277,20 @@ module Cucumber
 
       describe "diff!" do
         it "should detect a complex diff" do
-          t1 = table(%{
+          t1 = DataTable.from(%{
             | 1         | 22          | 333         | 4444         |
             | 55555     | 666666      | 7777777     | 88888888     |
             | 999999999 | 0000000000  | 01010101010 | 121212121212 |
             | 4000      | ABC         | DEF         | 50000        |
-          }, __FILE__, __LINE__)
+          })
 
-          t2 = table(%{
+          t2 = DataTable.from(%{
             | a     | 4444     | 1         |
             | bb    | 88888888 | 55555     |
             | ccc   | xxxxxxxx | 999999999 |
             | dddd  | 4000     | 300       |
             | e     | 50000    | 4000      |
-          }, __FILE__, __LINE__)
+          })
           expect { t1.diff!(t2) }.to raise_error
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
@@ -303,11 +303,11 @@ module Cucumber
         end
 
         it "should not change table when diffed with identical" do
-          t = table(%{
+          t = DataTable.from(%{
             |a|b|c|
             |d|e|f|
             |g|h|i|
-          }, __FILE__, __LINE__)
+          })
           t.diff!(t.dup)
           expect( t.to_s(:indent => 12, :color => false) ).to eq %{
             |     a |     b |     c |
@@ -317,11 +317,11 @@ module Cucumber
         end
 
         it "should inspect missing and surplus cells" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['name',  'male', 'lastname', 'swedish'],
             ['aslak', 'true', 'hellesøy', 'false']
           ])
-          t2 = DataTable.new([
+          t2 = DataTable.from([
             ['name',  'male', 'lastname', 'swedish'],
             ['aslak', true,   'hellesøy', false]
           ])
@@ -335,12 +335,12 @@ module Cucumber
         end
 
         it "should allow column mapping of target before diffing" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['name',  'male'],
             ['aslak', 'true']
           ])
           t1.map_column!('male') { |m| m == 'true' }
-          t2 = DataTable.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
@@ -352,14 +352,14 @@ module Cucumber
         end
 
         it "should allow column mapping of argument before diffing" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
           t1.map_column!('male') {
             'true'
           }
-          t2 = DataTable.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', 'true']
           ])
@@ -371,13 +371,13 @@ module Cucumber
         end
 
         it "should allow header mapping before diffing" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['Name',  'Male'],
             ['aslak', 'true']
           ])
           t1.map_headers!('Name' => 'name', 'Male' => 'male')
           t1.map_column!('male') { |m| m == 'true' }
-          t2 = DataTable.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
@@ -389,11 +389,11 @@ module Cucumber
         end
 
         it "should detect seemingly identical tables as different" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['X',  'Y'],
             ['2', '1']
           ])
-          t2 = DataTable.new([
+          t2 = DataTable.from([
             ['X',  'Y'],
             [2, 1]
           ])
@@ -406,7 +406,7 @@ module Cucumber
         end
 
         it "should not allow mappings that match more than 1 column" do
-          t1 = DataTable.new([
+          t1 = DataTable.from([
             ['Cuke',  'Duke'],
             ['Foo', 'Bar']
           ])
@@ -418,85 +418,91 @@ module Cucumber
 
         describe "raising" do
           before do
-            @t = table(%{
+            @t = DataTable.from(%{
               | a | b |
               | c | d |
-            }, __FILE__, __LINE__)
+            })
             expect( @t ).not_to eq nil
           end
 
           it "should raise on missing rows" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b |
-            }, __FILE__, __LINE__)
+            })
             expect( lambda { @t.dup.diff!(t) } ).to raise_error
             expect { @t.dup.diff!(t, :missing_row => false) }.not_to raise_error
           end
 
           it "should not raise on surplus rows when surplus is at the end" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b |
               | c | d |
               | e | f |
-            }, __FILE__, __LINE__)
+            })
             expect { @t.dup.diff!(t) }.to raise_error
             expect { @t.dup.diff!(t, :surplus_row => false) }.not_to raise_error
           end
 
           it "should not raise on surplus rows when surplus is interleaved" do
-            t1 = table(%{
+            t1 = DataTable.from(%{
               | row_1 | row_2 |
               | four  | 4     |
-            }, __FILE__, __LINE__)
-            t2 = table(%{
+            })
+            t2 = DataTable.from(%{
               | row_1 | row_2 |
               | one   | 1     |
               | two   | 2     |
               | three | 3     |
               | four  | 4     |
               | five  | 5     |
-            }, __FILE__, __LINE__)
+            })
             expect { t1.dup.diff!(t2) }.to raise_error
 
             expect { t1.dup.diff!(t2, :surplus_row => false) }.not_to raise_error
           end
 
           it "should raise on missing columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | a |
               | c |
-            }, __FILE__, __LINE__)
+            })
             expect { @t.dup.diff!(t) }.to raise_error
             expect { @t.dup.diff!(t, :missing_col => false) }.not_to raise_error
           end
 
           it "should not raise on surplus columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b | x |
               | c | d | y |
-            }, __FILE__, __LINE__)
+            })
             expect { @t.dup.diff!(t) }.not_to raise_error
             expect { @t.dup.diff!(t, :surplus_col => true) }.to raise_error
           end
 
           it "should not raise on misplaced columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | b | a |
               | d | c |
-            }, __FILE__, __LINE__)
+            })
             expect { @t.dup.diff!(t) }.not_to raise_error
             expect { @t.dup.diff!(t, :misplaced_col => true) }.to raise_error
           end
         end
 
-        def table(text, file, offset)
-          DataTable.parse(text, file, offset)
+        it "can compare to an Array" do
+          t = DataTable.from(%{
+            | b | a |
+            | d | c |
+          })
+          other = [ %w{b a}, %w{d c} ]
+
+          expect { t.diff!(other) }.not_to raise_error
         end
       end
 
-      describe "#new" do
+      describe "#from" do
         it "should allow Array of Hash" do
-          t1 = DataTable.new([{'name' => 'aslak', 'male' => 'true'}])
+          t1 = DataTable.from([{'name' => 'aslak', 'male' => 'true'}])
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     male |     name  |
             |     true |     aslak |

data/spec/cucumber/project_initializer_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'tmpdir'
+
+module Cucumber
+  describe ProjectInitializer, :isolated_home => true do
+    let(:command_line_config) { ProjectInitializer.new }
+
+    before do
+      allow(command_line_config).to receive(:puts)
+    end
+
+    context "no files created" do
+      around(:example) do |example|
+
+        dir = Dir.mktmpdir
+        original_dir = Dir.pwd
+        begin
+          FileUtils.cd dir
+          example.call
+        ensure
+          FileUtils.cd original_dir
+          FileUtils.rm_rf dir
+        end
+      end
+
+      it "should create features directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features$)
+        command_line_config.run
+      end
+
+      it "should create step_definitions directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/step_definitions$)
+        command_line_config.run
+      end
+
+      it "should create support directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support$)
+        command_line_config.run
+      end
+
+      it "should create env.rb directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support/env.rb$)
+        command_line_config.run
+      end
+
+    end
+
+    context "files created" do
+      around(:example) do |example|
+        dir = Dir.mktmpdir
+        FileUtils.mkdir_p "#{dir}/features"
+        FileUtils.mkdir_p "#{dir}/features/step_definitions"
+        FileUtils.mkdir_p "#{dir}/features/support"
+        FileUtils.touch "#{dir}/features/support/env.rb"
+        original_dir = Dir.pwd
+        begin
+          FileUtils.cd dir
+          example.call
+        ensure
+          FileUtils.cd original_dir
+          FileUtils.rm_rf dir
+        end
+      end
+
+      it "should not create features directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features$)
+        command_line_config.run
+      end
+
+      it "should not create step_definitions directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/step_definitions$)
+        command_line_config.run
+      end
+
+      it "should not create support directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support$)
+        command_line_config.run
+      end
+
+      it "should not create env.rb directory" do
+        expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support/env.rb$)
+        command_line_config.run
+      end
+
+    end
+  end
+end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -91,7 +91,7 @@ module Cucumber
           dsl.World {}
 
           begin
-            rb.before(nil)
+            rb.begin_scenario(nil)
             raise "Should fail"
           rescue RbSupport::NilWorld => e
             expect(e.message).to eq "World procs should never return nil"
@@ -111,7 +111,7 @@ module Cucumber
 
         it "implicitlys extend world with modules" do
           dsl.World(ModuleOne, ModuleTwo)
-          rb.before(double('scenario').as_null_object)
+          rb.begin_scenario(double('scenario').as_null_object)
           class << rb.current_world
             extend RSpec::Matchers
 

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -7,18 +7,23 @@ module Cucumber
       let(:user_interface) { double('user interface') }
       let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
       let(:rb)             { support_code.load_programming_language('rb') }
+      let(:scenario)       { double('scenario', iso_code: 'en').as_null_object }
       let(:dsl) do
         rb
         Object.new.extend(Cucumber::RbSupport::RbDsl)
       end
 
       before do
-        rb.before(double('scenario').as_null_object)
+        rb.begin_scenario(scenario)
         $inside = nil
       end
 
       def run_step(text)
-        support_code.step_match(text).invoke(MultilineArgument::None.new)
+        step_match(text).invoke(MultilineArgument::None.new)
+      end
+
+      def step_match(text)
+        support_code.step_match(text)
       end
 
       it "allows calling of other steps" do
@@ -80,16 +85,33 @@ module Cucumber
 
           run_step "With symbol on symbol"
         end
+
+        it "has the correct location" do
+          dsl.Given /With symbol/, :with_symbol
+          expect(step_match("With symbol").file_colon_line).to eq "spec/cucumber/rb_support/rb_step_definition_spec.rb:#{__LINE__-1}"
+        end
       end
 
-      it "raises Undefined when inside step is not defined" do
+      it "raises UndefinedDynamicStep when inside step is not defined" do
         dsl.Given(/Outside/) do
           step 'Inside'
         end
 
         expect(-> {
           run_step "Outside"
-        }).to raise_error(Cucumber::Undefined)
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it "raises UndefinedDynamicStep when an undefined step is parsed dynamically" do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+          }
+        end
+
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
       end
 
       it "allows forced pending" do
@@ -111,14 +133,17 @@ module Cucumber
         }).to raise_error(Cucumber::ArityMismatchError)
       end
 
-      it "does not allow modification of args since it messes up pretty formatting" do
+      it "does not modify the step_match arg when arg is modified in a step" do
         dsl.Given(/My car is (.*)/) do |colour|
           colour << "xxx"
         end
 
+        step_name = "My car is white"
+        step_args = step_match(step_name).args
+
         expect(-> {
-          run_step "My car is white"
-        }).to raise_error(RuntimeError, /can't modify frozen String/i)
+          run_step step_name
+        }).not_to change{ step_args.first }
       end
 
       it "allows puts" do

data/spec/cucumber/rb_support/rb_transform_spec.rb

@@ -9,6 +9,26 @@ module Cucumber
       end
 
       describe "#to_s" do
+        it "does not touch positive lookahead captures" do
+          expect(transform(/^xy(?=z)/).to_s).to eq "xy(?=z)"
+        end
+
+        it "does not touch negative lookahead captures" do
+          expect(transform(/^xy(?!z)/).to_s).to eq "xy(?!z)"
+        end
+
+        it "does not touch positive lookbehind captures" do
+          expect(transform(/^xy(?<=z)/).to_s).to eq "xy(?<=z)"
+        end
+
+        it "does not touch negative lookbehind captures" do
+          expect(transform(/^xy(?<!z)/).to_s).to eq "xy(?<!z)"
+        end
+
+        it "converts named captures" do
+          expect(transform(/^(?<str>xyz)/).to_s).to eq "(?:<str>xyz)"
+        end
+
         it "converts captures groups to non-capture groups" do
           expect(transform(/(a|b)bc/).to_s).to eq "(?:a|b)bc"
         end

data/spec/cucumber/rb_support/snippet_spec.rb

@@ -27,7 +27,7 @@ module Cucumber
           @pattern = 'A "string" with 4 spaces'
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^A "(.*?)" with (\\d+) spaces$/) do |arg1, arg2|
+          Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
             pending # Write code here that turns the phrase above into concrete actions
           end
           })
@@ -48,7 +48,7 @@ module Cucumber
           @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^I have (\\d+) "(.*?)" cukes in (\\d+) "(.*?)"$/) do |arg1, arg2, arg3, arg4, table|
+          Given(/^I have (\\d+) "([^"]*)" cukes in (\\d+) "([^"]*)"$/) do |arg1, arg2, arg3, arg4, table|
             # table is a Cucumber::Core::Ast::DataTable
             pending # Write code here that turns the phrase above into concrete actions
           end
@@ -59,7 +59,7 @@ module Cucumber
           @pattern = 'A "first" arg'
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^A "(.*?)" arg$/) do |arg1|
+          Given(/^A "([^"]*)" arg$/) do |arg1|
             pending # Write code here that turns the phrase above into concrete actions
           end
           })
@@ -69,7 +69,7 @@ module Cucumber
           @pattern = 'A "first" and "second" arg'
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^A "(.*?)" and "(.*?)" arg$/) do |arg1, arg2|
+          Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
             pending # Write code here that turns the phrase above into concrete actions
           end
           })
@@ -90,7 +90,7 @@ module Cucumber
           @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^A "(.*?)" arg$/) do |arg1, table|
+          Given(/^A "([^"]*)" arg$/) do |arg1, table|
             # table is a Cucumber::Core::Ast::DataTable
             pending # Write code here that turns the phrase above into concrete actions
           end
@@ -102,7 +102,7 @@ module Cucumber
           @multiline_argument = MultilineArgument.from("", Core::Ast::Location.new(""))
 
           expect(snippet_text).to eq unindented(%{
-          Given(/^A "(.*?)" arg$/) do |arg1, string|
+          Given(/^A "([^"]*)" arg$/) do |arg1, string|
             pending # Write code here that turns the phrase above into concrete actions
           end
           })

data/spec/cucumber/running_test_case_spec.rb

@@ -0,0 +1,83 @@
+require 'cucumber/running_test_case'
+require 'cucumber/core'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber
+  describe RunningTestCase do
+    include Core
+    include Core::Gherkin::Writer
+
+    attr_accessor :wrapped_test_case, :core_test_case
+
+    before do
+      receiver = double.as_null_object
+      allow(receiver).to receive(:test_case) { |core_test_case|
+        self.core_test_case = core_test_case
+        self.wrapped_test_case = RunningTestCase.new(core_test_case)
+      }
+      compile [gherkin_doc], receiver
+    end
+
+    context "for a regular scenario" do
+      let(:gherkin_doc) do
+        gherkin do
+          feature "feature name" do
+            scenario "scenario name" do
+              step "passing"
+            end
+          end
+        end
+      end
+
+      it "sets the scenario name correctly" do
+        expect(wrapped_test_case.name).to eq "scenario name"
+      end
+
+      it "sets the feature name correctly" do
+        expect(wrapped_test_case.feature.name).to eq "feature name"
+      end
+
+      it "exposes properties of the test_case" do
+        expect(wrapped_test_case.location).to eq core_test_case.location
+        expect(wrapped_test_case.source).to eq core_test_case.source
+        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
+      end
+    end
+
+    context "for a scenario outline" do
+      let(:gherkin_doc) do
+        gherkin do
+          feature "feature name" do
+            scenario_outline "scenario outline name" do
+              step "passing with <arg1> <arg2>"
+
+              examples "examples name" do
+                row "arg1", "arg2"
+                row "a", "b"
+              end
+            end
+          end
+        end
+      end
+
+      it "sets the test case's name correctly" do
+        expect(wrapped_test_case.name).to eq "scenario outline name, examples name (#1)"
+      end
+
+      it "sets the feature name correctly" do
+        expect(wrapped_test_case.feature.name).to eq "feature name"
+      end
+
+      it "exposes properties of the test_case" do
+        expect(wrapped_test_case.location).to eq core_test_case.location
+        expect(wrapped_test_case.source).to eq core_test_case.source
+        expect(wrapped_test_case.keyword).to eq core_test_case.keyword
+      end
+
+      it "exposes the examples table row cell values" do
+        expect(wrapped_test_case.cell_values).to eq ["a", "b"]
+      end
+
+    end
+  end
+end