cucumber 3.0.0.pre.1 → 3.0.0.pre.2

data/spec/cucumber/glue/step_definition_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'cucumber/glue/registry_and_more'
+
+module Cucumber
+  module Glue
+    describe StepDefinition do
+      let(:user_interface) { double('user interface') }
+      let(:support_code)   { Cucumber::Runtime::SupportCode.new(user_interface) }
+      let(:registry)       { support_code.registry }
+      let(:scenario)       { double('scenario', iso_code: 'en').as_null_object }
+      let(:dsl) do
+        registry
+        Object.new.extend(Cucumber::Glue::Dsl)
+      end
+
+      before do
+        registry.begin_scenario(scenario)
+        $inside = nil
+      end
+
+      def run_step(text)
+        step_match(text).invoke(MultilineArgument::None.new)
+      end
+
+      def step_match(text)
+        StepMatchSearch.new(registry.method(:step_matches), Configuration.default).call(text).first
+      end
+
+      it 'allows calling of other steps' do
+        dsl.Given(/Outside/) do
+          step 'Inside'
+        end
+        dsl.Given(/Inside/) do
+          $inside = true
+        end
+
+        run_step 'Outside'
+
+        expect($inside).to be true
+      end
+
+      it 'allows calling of other steps with inline arg' do
+        dsl.Given(/Outside/) do
+          step 'Inside', table([['inside']])
+        end
+        dsl.Given(/Inside/) do |t|
+          $inside = t.raw[0][0]
+        end
+
+        run_step 'Outside'
+
+        expect($inside).to eq 'inside'
+      end
+
+      context 'mapping to world methods' do
+        it 'calls a method on the world when specified with a symbol' do
+          expect(registry.current_world).to receive(:with_symbol)
+
+          dsl.Given(/With symbol/, :with_symbol)
+
+          run_step 'With symbol'
+        end
+
+        it 'calls a method on a specified object' do
+          target = double('target')
+
+          allow(registry.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on block/, :with_symbol, :on => lambda { target })
+
+          expect(target).to receive(:with_symbol)
+
+          run_step 'With symbol on block'
+        end
+
+        it 'calls a method on a specified world attribute' do
+          target = double('target')
+
+          allow(registry.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on symbol/, :with_symbol, :on => :target)
+
+          expect(target).to receive(:with_symbol)
+
+          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/glue/step_definition_spec.rb:#{__LINE__-1}"
+        end
+      end
+
+      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::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 'raises UndefinedDynamicStep when an undefined step with doc string is parsed dynamically' do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+            """
+            abc
+            """
+          }
+        end
+
+        expect(-> {
+          run_step 'Outside'
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it 'raises UndefinedDynamicStep when an undefined step with data table is parsed dynamically' do
+        dsl.Given(/Outside/) do
+          steps %{
+            Given Inside
+             | a |
+             | 1 |
+          }
+        end
+
+        expect(-> {
+          run_step 'Outside'
+        }).to raise_error(Cucumber::UndefinedDynamicStep)
+      end
+
+      it 'allows forced pending' do
+        dsl.Given(/Outside/) do
+          pending('Do me!')
+        end
+
+        expect(-> {
+          run_step 'Outside'
+        }).to raise_error(Cucumber::Pending, 'Do me!')
+      end
+
+      it 'raises ArityMismatchError when the number of capture groups differs from the number of step arguments' do
+        dsl.Given(/No group: \w+/) do |arg|
+        end
+
+        expect(-> {
+          run_step 'No group: arg'
+        }).to raise_error(Cucumber::Glue::ArityMismatchError)
+      end
+
+      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 step_name
+        }).not_to change{ step_args.first }
+      end
+
+      it 'allows puts' do
+        expect(user_interface).to receive(:puts).with('wasup')
+        dsl.Given(/Loud/) do
+          puts 'wasup'
+        end
+        run_step 'Loud'
+      end
+
+      it 'recognizes $arg style captures' do
+        arg_value = 'up'
+        dsl.Given 'capture this: {word}' do |arg|
+          expect(arg).to eq arg_value
+        end
+        run_step 'capture this: up'
+      end
+
+      it 'has a JSON representation of the signature' do
+        expect(StepDefinition.new(registry, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash).to eq({
+          source: {
+            type: 'regular expression',
+            expression: 'I CAN HAZ (\\d+) CUKES'
+          },
+          regexp: {
+            source: 'I CAN HAZ (\\d+) CUKES', flags: 'i'
+          }
+        })
+      end
+    end
+  end
+end

data/spec/cucumber/hooks_spec.rb

@@ -2,15 +2,15 @@
 require 'cucumber/hooks'
 module Cucumber::Hooks
   shared_examples_for 'a source node' do
-    it "responds to name" do
+    it 'responds to name' do
       expect( subject.name ).to be_a(String)
     end
 
-    it "responds to location" do
+    it 'responds to location' do
       expect( subject.location ).to eq(location)
     end
 
-    it "responds to match_locations?" do
+    it 'responds to match_locations?' do
       expect( subject.match_locations? [location] ).to be_truthy
       expect( subject.match_locations? [] ).to be_falsey
     end

data/spec/cucumber/multiline_argument/data_table_spec.rb

@@ -13,30 +13,30 @@ module Cucumber
         ])
       end
 
-      it "should have rows" do
+      it 'should have rows' do
         expect( @table.cells_rows[0].map{|cell| cell.value} ).to eq %w{one four seven}
       end
 
-      it "should have columns" do
+      it 'should have columns' do
         expect( @table.columns[1].map{|cell| cell.value} ).to eq %w{four 55555}
       end
 
-      it "should have same cell objects in rows and columns" do
+      it 'should have same cell objects in rows and columns' do
         # 666666
         expect( @table.cells_rows[1][2] ).to equal(@table.columns[2][1])
       end
 
-      it "should be convertible to an array of hashes" do
+      it 'should be convertible to an array of hashes' do
         expect( @table.hashes ).to eq [
           {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
         ]
       end
 
-      it "should accept symbols as keys for the hashes" do
+      it 'should accept symbols as keys for the hashes' do
         expect( @table.hashes.first[:one] ).to eq '4444'
       end
 
-      it "should return the row values in order" do
+      it 'should return the row values in order' do
         expect( @table.rows.first ).to eq %w{4444 55555 666666}
       end
 
@@ -56,12 +56,12 @@ module Cucumber
       end
 
       describe '#map_column!' do
-        it "should allow mapping columns" do
+        it 'should allow mapping columns' do
           @table.map_column!('one') { |v| v.to_i }
           expect( @table.hashes.first['one'] ).to eq 4444
         end
 
-        it "applies the block once to each value" do
+        it 'applies the block once to each value' do
           headers = ['header']
           rows = ['value']
           table = DataTable.from [headers, rows]
@@ -71,43 +71,43 @@ module Cucumber
           expect( count ).to eq rows.size
         end
 
-        it "should allow mapping columns and take a symbol as the column name" do
+        it 'should allow mapping columns and take a symbol as the column name' do
           @table.map_column!(:one) { |v| v.to_i }
           expect( @table.hashes.first['one'] ).to eq 4444
         end
 
-        it "should allow mapping columns and modify the rows as well" do
+        it 'should allow mapping columns and modify the rows as well' do
           @table.map_column!(:one) { |v| v.to_i }
           expect( @table.rows.first ).to include(4444)
           expect( @table.rows.first ).to_not include('4444')
         end
 
-        it "should pass silently if a mapped column does not exist in non-strict mode" do
+        it 'should pass silently if a mapped column does not exist in non-strict mode' do
           expect {
             @table.map_column!('two', false) { |v| v.to_i }
             @table.hashes
           }.not_to raise_error
         end
 
-        it "should fail if a mapped column does not exist in strict mode" do
+        it 'should fail if a mapped column does not exist in strict mode' do
           expect {
             @table.map_column!('two', true) { |v| v.to_i }
             @table.hashes
           }.to raise_error('The column named "two" does not exist')
         end
 
-        it "should return the table" do
+        it 'should return the table' do
           expect( (@table.map_column!(:one) { |v| v.to_i }) ).to eq @table
         end
       end
 
       describe '#map_column' do
-        it "should allow mapping columns" do
+        it 'should allow mapping columns' do
           new_table = @table.map_column('one') { |v| v.to_i }
           expect( new_table.hashes.first['one'] ).to eq 4444
         end
 
-        it "applies the block once to each value" do
+        it 'applies the block once to each value' do
           headers = ['header']
           rows = ['value']
           table = DataTable.from [headers, rows]
@@ -117,37 +117,37 @@ module Cucumber
           expect( count ).to eq rows.size
         end
 
-        it "should allow mapping columns and take a symbol as the column name" do
+        it 'should allow mapping columns and take a symbol as the column name' do
           new_table = @table.map_column(:one) { |v| v.to_i }
           expect( new_table.hashes.first['one'] ).to eq 4444
         end
 
-        it "should allow mapping columns and modify the rows as well" do
+        it 'should allow mapping columns and modify the rows as well' do
           new_table = @table.map_column(:one) { |v| v.to_i }
           expect( new_table.rows.first ).to include(4444)
           expect( new_table.rows.first ).to_not include('4444')
         end
 
-        it "should pass silently if a mapped column does not exist in non-strict mode" do
+        it 'should pass silently if a mapped column does not exist in non-strict mode' do
           expect {
             new_table = @table.map_column('two', false) { |v| v.to_i }
             new_table.hashes
           }.not_to raise_error
         end
 
-        it "should fail if a mapped column does not exist in strict mode" do
+        it 'should fail if a mapped column does not exist in strict mode' do
           expect {
             new_table = @table.map_column('two', true) { |v| v.to_i }
             new_table.hashes
           }.to raise_error('The column named "two" does not exist')
         end
 
-        it "should return a new table" do
+        it 'should return a new table' do
           expect( (@table.map_column(:one) { |v| v.to_i }) ).to_not eq @table
         end
       end
 
-      describe "#match" do
+      describe '#match' do
         before(:each) do
           @table = DataTable.from([
             %w{one four seven},
@@ -155,18 +155,18 @@ module Cucumber
           ])
         end
 
-        it "returns nil if headers do not match" do
+        it 'returns nil if headers do not match' do
           expect( @table.match('does,not,match') ).to be_nil
         end
-        it "requires a table: prefix on match" do
+        it 'requires a table: prefix on match' do
           expect( @table.match('table:one,four,seven') ).to_not be_nil
         end
-        it "does not match if no table: prefix on match" do
+        it 'does not match if no table: prefix on match' do
           expect( @table.match('one,four,seven') ).to be_nil
         end
       end
 
-      describe "#transpose" do
+      describe '#transpose' do
         before(:each) do
           @table = DataTable.from([
             %w{one 1111},
@@ -174,14 +174,14 @@ module Cucumber
           ])
         end
 
-        it "should be convertible in to an array where each row is a hash" do
+        it 'should be convertible in to an array where each row is a hash' do
           expect( @table.transpose.hashes[0] ).to eq('one' => '1111', 'two' => '22222')
         end
       end
 
-      describe "#rows_hash" do
+      describe '#rows_hash' do
 
-        it "should return a hash of the rows" do
+        it 'should return a hash of the rows' do
           table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
@@ -199,7 +199,7 @@ module Cucumber
           }.to raise_error('The table must have exactly 2 columns')
         end
 
-        it "should support header and column mapping" do
+        it 'should support header and column mapping' do
           table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
@@ -218,30 +218,30 @@ module Cucumber
           ])
         end
 
-        it "renames the columns to the specified values in the provided hash" do
+        it 'renames the columns to the specified values in the provided hash' do
           @table.map_headers!('one' => :three)
           expect( @table.hashes.first[:three] ).to eq '4444'
         end
 
-        it "allows renaming columns using regexp" do
+        it 'allows renaming columns using regexp' do
           @table.map_headers!(/one|uno/ => :three)
           expect( @table.hashes.first[:three] ).to eq '4444'
         end
 
-        it "copies column mappings" do
+        it 'copies column mappings' do
           @table.map_column!('one') { |v| v.to_i }
           @table.map_headers!('one' => 'three')
           expect( @table.hashes.first['three'] ).to eq 4444
         end
 
-        it "takes a block and operates on all the headers with it" do
+        it 'takes a block and operates on all the headers with it' do
           table.map_headers! do |header|
             header.downcase
           end
           expect( table.hashes.first.keys ).to match %w[hello world]
         end
 
-        it "treats the mappings in the provided hash as overrides when used with a block" do
+        it 'treats the mappings in the provided hash as overrides when used with a block' do
           table.map_headers!('WORLD' => 'foo') do |header|
             header.downcase
           end
@@ -258,23 +258,23 @@ module Cucumber
           ])
         end
 
-        it "renames the columns to the specified values in the provided hash" do
+        it 'renames the columns to the specified values in the provided hash' do
           table2 = @table.map_headers('one' => :three)
           expect( table2.hashes.first[:three] ).to eq '4444'
         end
 
-        it "allows renaming columns using regexp" do
+        it 'allows renaming columns using regexp' do
           table2 = @table.map_headers(/one|uno/ => :three)
           expect( table2.hashes.first[:three] ).to eq '4444'
         end
 
-        it "copies column mappings" do
+        it 'copies column mappings' do
           @table.map_column!('one') { |v| v.to_i }
           table2 = @table.map_headers('one' => 'three')
           expect( table2.hashes.first['three'] ).to eq 4444
         end
 
-        it "takes a block and operates on all the headers with it" do
+        it 'takes a block and operates on all the headers with it' do
           table2 = table.map_headers do |header|
             header.downcase
           end
@@ -282,7 +282,7 @@ module Cucumber
           expect( table2.hashes.first.keys ).to match %w[hello world]
         end
 
-        it "treats the mappings in the provided hash as overrides when used with a block" do
+        it 'treats the mappings in the provided hash as overrides when used with a block' do
           table2 = table.map_headers('WORLD' => 'foo') do |header|
             header.downcase
           end
@@ -291,8 +291,8 @@ module Cucumber
         end
       end
 
-      describe "diff!" do
-        it "should detect a complex diff" do
+      describe 'diff!' do
+        it 'should detect a complex diff' do
           t1 = DataTable.from(%{
             | 1         | 22          | 333         | 4444         |
             | 55555     | 666666      | 7777777     | 88888888     |
@@ -307,18 +307,19 @@ module Cucumber
             | dddd  | 4000     | 300       |
             | e     | 50000    | 4000      |
           })
-          expect { t1.diff!(t2) }.to raise_error
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
-            |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
-            | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
-            | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
-            | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
-            |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
-          }
+          expect { t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+            expect(error.table.to_s(indent: 14, color: false)).to eq %{
+              |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
+              |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
+              | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
+              | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
+              | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
+              |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
+            }
+          end
         end
 
-        it "should not change table when diffed with identical" do
+        it 'should not change table when diffed with identical' do
           t = DataTable.from(%{
             |a|b|c|
             |d|e|f|
@@ -332,8 +333,48 @@ module Cucumber
           }
         end
 
-        context "in case of duplicate header values" do
-          it "raises no error for two identical tables" do
+        context 'with empty tables' do
+          it 'should allow diffing empty tables' do
+            t1 = DataTable.from([[]])
+            t2 = DataTable.from([[]])
+            expect{ t1.diff!(t2) }.not_to raise_error
+          end
+
+          it 'should be able to diff when the right table is empty' do
+            t1 = DataTable.from(%{
+              |a|b|c|
+              |d|e|f|
+              |g|h|i|
+            })
+            t2 = DataTable.from([[]])
+            expect { t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+              expect(error.table.to_s(indent: 16, color: false)).to eq %{
+                | (-) a | (-) b | (-) c |
+                | (-) d | (-) e | (-) f |
+                | (-) g | (-) h | (-) i |
+              }
+            end
+          end
+
+          it 'should be able to diff when the left table is empty' do
+            t1 = DataTable.from([[]])
+            t2 = DataTable.from(%{
+              |a|b|c|
+              |d|e|f|
+              |g|h|i|
+            })
+            expect { t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+              expect(error.table.to_s(indent: 16, color: false)).to eq %{
+                | (+) a | (+) b | (+) c |
+                | (+) d | (+) e | (+) f |
+                | (+) g | (+) h | (+) i |
+              }
+            end
+          end
+        end
+
+        context 'in case of duplicate header values' do
+          it 'raises no error for two identical tables' do
             t = DataTable.from(%{
             |a|a|c|
             |d|e|f|
@@ -347,7 +388,7 @@ module Cucumber
           }
           end
 
-          it "detects a diff in one cell" do
+          it 'detects a diff in one cell' do
             t1 = DataTable.from(%{
             |a|a|c|
             |d|e|f|
@@ -358,16 +399,17 @@ module Cucumber
             |d|oops|f|
             |g|h|i|
                                 })
-            expect{ t1.diff!(t2) }.to raise_error
-            expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     a |     a    |     c |
-            | (-) d | (-) e    | (-) f |
-            | (+) d | (+) oops | (+) f |
-            |     g |     h    |     i |
-          }
+            expect{ t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+              expect(error.table.to_s(indent: 16, color: false)).to eq %{
+                |     a |     a    |     c |
+                | (-) d | (-) e    | (-) f |
+                | (+) d | (+) oops | (+) f |
+                |     g |     h    |     i |
+              }
+            end
           end
 
-          it "detects missing columns" do
+          it 'detects missing columns' do
             t1 = DataTable.from(%{
             |a|a|b|c|
             |d|d|e|f|
@@ -378,15 +420,16 @@ module Cucumber
             |d|e|f|
             |g|h|i|
                                 })
-            expect{ t1.diff!(t2) }.to raise_error
-            expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     a | (-) a |     b |     c |
-            |     d | (-) d |     e |     f |
-            |     g | (-) g |     h |     i |
-          }
+            expect{ t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+              expect(error.table.to_s(indent: 16, color: false)).to eq %{
+                |     a | (-) a |     b |     c |
+                |     d | (-) d |     e |     f |
+                |     g | (-) g |     h |     i |
+              }
+            end
           end
 
-          it "detects surplus columns" do
+          it 'detects surplus columns' do
             t1 = DataTable.from(%{
             |a|b|c|
             |d|e|f|
@@ -397,42 +440,43 @@ module Cucumber
             |d|e|d|f|
             |g|h|g|i|
                                 })
-            expect{ t1.diff!(t2, :surplus_col => true) }.to raise_error
-            expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     a |     b |     c | (+) a |
-            |     d |     e |     f | (+) d |
-            |     g |     h |     i | (+) g |
-          }
+            expect{ t1.diff!(t2, :surplus_col => true) }.to raise_error(DataTable::Different) do |error|
+              expect(error.table.to_s(indent: 16, color: false)).to eq %{
+                |     a |     b |     c | (+) a |
+                |     d |     e |     f | (+) d |
+                |     g |     h |     i | (+) g |
+              }
+            end
           end
         end
 
-        it "should inspect missing and surplus cells" do
+        it 'should inspect missing and surplus cells' do
           t1 = DataTable.from([
-            ['name',  'male', 'lastname', 'swedish'],
-            ['aslak', 'true', 'hellesøy', 'false']
+            %w(name  male lastname swedish),
+            %w(aslak true hellesøy false)
           ])
           t2 = DataTable.from([
-            ['name',  'male', 'lastname', 'swedish'],
-            ['aslak', true,   'hellesøy', false]
+            %w(name    male   lastname   swedish),
+             ['aslak', true, 'hellesøy', false]
           ])
-          expect { t1.diff!(t2) }.to raise_error
-
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     name  |     male       |     lastname |     swedish     |
-            | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
-            | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
-          }
+          expect { t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+            expect(error.table.to_s(indent: 14, color: false)).to eq %{
+              |     name  |     male       |     lastname |     swedish     |
+              | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
+              | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
+            }
+          end
         end
 
-        it "should allow column mapping of target before diffing" do
+        it 'should allow column mapping of target before diffing' do
           t1 = DataTable.from([
-            ['name',  'male'],
-            ['aslak', 'true']
+            %w(name  male),
+            %w(aslak true)
           ])
           t1.map_column!('male') { |m| m == 'true' }
           t2 = DataTable.from([
-            ['name',  'male'],
-            ['aslak', true]
+            %w(name    male),
+             ['aslak', true]
           ])
           t1.diff!(t2)
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
@@ -441,17 +485,17 @@ module Cucumber
           }
         end
 
-        it "should allow column mapping of argument before diffing" do
+        it 'should allow column mapping of argument before diffing' do
           t1 = DataTable.from([
-            ['name',  'male'],
-            ['aslak', true]
+            %w(name    male),
+             ['aslak', true]
           ])
           t1.map_column!('male') {
             'true'
           }
           t2 = DataTable.from([
-            ['name',  'male'],
-            ['aslak', 'true']
+            %w(name  male),
+            %w(aslak true)
           ])
           t2.diff!(t1)
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
@@ -460,16 +504,16 @@ module Cucumber
           }
         end
 
-        it "should allow header mapping before diffing" do
+        it 'should allow header mapping before diffing' do
           t1 = DataTable.from([
-            ['Name',  'Male'],
-            ['aslak', 'true']
+            %w(Name  Male),
+            %w(aslak true)
           ])
           t1.map_headers!('Name' => 'name', 'Male' => 'male')
           t1.map_column!('male') { |m| m == 'true' }
           t2 = DataTable.from([
-            ['name',  'male'],
-            ['aslak', true]
+            %w(name    male),
+             ['aslak', true]
           ])
           t1.diff!(t2)
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
@@ -478,27 +522,28 @@ module Cucumber
           }
         end
 
-        it "should detect seemingly identical tables as different" do
+        it 'should detect seemingly identical tables as different' do
           t1 = DataTable.from([
-            ['X',  'Y'],
-            ['2', '1']
+            %w(X Y),
+            %w(2 1)
           ])
           t2 = DataTable.from([
-            ['X',  'Y'],
-            [2, 1]
+            %w(X  Y),
+              [2, 1]
           ])
-          expect { t1.diff!(t2) }.to raise_error
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     X       |     Y       |
-            | (-) (i) "2" | (-) (i) "1" |
-            | (+) (i) 2   | (+) (i) 1   |
-          }
+          expect { t1.diff!(t2) }.to raise_error(DataTable::Different) do |error|
+            expect(error.table.to_s(indent: 14, color: false)).to eq %{
+              |     X       |     Y       |
+              | (-) (i) "2" | (-) (i) "1" |
+              | (+) (i) 2   | (+) (i) 1   |
+            }
+          end
         end
 
-        it "should not allow mappings that match more than 1 column" do
+        it 'should not allow mappings that match more than 1 column' do
           t1 = DataTable.from([
-            ['Cuke',  'Duke'],
-            ['Foo', 'Bar']
+            %w(Cuke Duke),
+            %w(Foo  Bar)
           ])
           expect do
             t1.map_headers!(/uk/ => 'u')
@@ -506,7 +551,7 @@ module Cucumber
           end.to raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
         end
 
-        describe "raising" do
+        describe 'raising' do
           before do
             @t = DataTable.from(%{
               | a | b |
@@ -515,25 +560,25 @@ module Cucumber
             expect( @t ).not_to eq nil
           end
 
-          it "should raise on missing rows" do
+          it 'should raise on missing rows' do
             t = DataTable.from(%{
               | a | b |
             })
-            expect( lambda { @t.dup.diff!(t) } ).to raise_error
+            expect { @t.dup.diff!(t) }.to raise_error(DataTable::Different)
             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
+          it 'should not raise on surplus rows when surplus is at the end' do
             t = DataTable.from(%{
               | a | b |
               | c | d |
               | e | f |
             })
-            expect { @t.dup.diff!(t) }.to raise_error
+            expect { @t.dup.diff!(t) }.to raise_error(DataTable::Different)
             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
+          it 'should not raise on surplus rows when surplus is interleaved' do
             t1 = DataTable.from(%{
               | row_1 | row_2 |
               | four  | 4     |
@@ -546,40 +591,39 @@ module Cucumber
               | four  | 4     |
               | five  | 5     |
             })
-            expect { t1.dup.diff!(t2) }.to raise_error
-
+            expect { t1.dup.diff!(t2) }.to raise_error(DataTable::Different)
             expect { t1.dup.diff!(t2, :surplus_row => false) }.not_to raise_error
           end
 
-          it "should raise on missing columns" do
+          it 'should raise on missing columns' do
             t = DataTable.from(%{
               | a |
               | c |
             })
-            expect { @t.dup.diff!(t) }.to raise_error
+            expect { @t.dup.diff!(t) }.to raise_error(DataTable::Different)
             expect { @t.dup.diff!(t, :missing_col => false) }.not_to raise_error
           end
 
-          it "should not raise on surplus columns" do
+          it 'should not raise on surplus columns' do
             t = DataTable.from(%{
               | a | b | x |
               | c | d | y |
             })
             expect { @t.dup.diff!(t) }.not_to raise_error
-            expect { @t.dup.diff!(t, :surplus_col => true) }.to raise_error
+            expect { @t.dup.diff!(t, :surplus_col => true) }.to raise_error(DataTable::Different)
           end
 
-          it "should not raise on misplaced columns" do
+          it 'should not raise on misplaced columns' do
             t = DataTable.from(%{
               | b | a |
               | d | c |
             })
             expect { @t.dup.diff!(t) }.not_to raise_error
-            expect { @t.dup.diff!(t, :misplaced_col => true) }.to raise_error
+            expect { @t.dup.diff!(t, :misplaced_col => true) }.to raise_error(DataTable::Different)
           end
         end
 
-        it "can compare to an Array" do
+        it 'can compare to an Array' do
           t = DataTable.from(%{
             | b | a |
             | d | c |
@@ -590,8 +634,8 @@ module Cucumber
         end
       end
 
-      describe "#from" do
-        it "should allow Array of Hash" do
+      describe '#from' do
+        it 'should allow Array of Hash' do
           t1 = DataTable.from([{'name' => 'aslak', 'male' => 'true'}])
           expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     male |     name  |