cucumber 3.0.1 → 3.2.0

data/spec/cucumber/glue/snippet_spec.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/cucumber_expressions/parameter_type_registry'
-require 'cucumber/cucumber_expressions/parameter_type'
-require 'cucumber/cucumber_expressions/cucumber_expression_generator'
-require 'cucumber/glue/snippet'
-
-module Cucumber
-  module Glue
-    describe Snippet do
-      let(:code_keyword) { 'Given' }
-
-      before do
-        @step_text = 'we have a missing step'
-        @multiline_argument = Core::Ast::EmptyMultilineArgument.new
-        @registry = CucumberExpressions::ParameterTypeRegistry.new
-        @cucumber_expression_generator = CucumberExpressions::CucumberExpressionGenerator.new(@registry)
-      end
-
-      let(:snippet) do
-        snippet_class.new(@cucumber_expression_generator, code_keyword, @step_text, @multiline_argument)
-      end
-
-      def unindented(s)
-        s.split("\n")[1..-2].join("\n").indent(-10)
-      end
-
-      describe Snippet::Regexp do
-        let(:snippet_class) { Snippet::Regexp }
-        let(:snippet_text) { snippet.to_s }
-
-        it 'wraps snippet patterns in parentheses' do
-          @step_text = 'A "string" with 4 spaces'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'recognises numbers in name and make according regexp' do
-          @step_text = 'Cloud 9 yeah'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^Cloud (\\d+) yeah$/) do |arg1|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'recognises a mix of ints, strings and why not a table too' do
-          @step_text = 'I have 9 "awesome" cukes in 37 "boxes"'
-          @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|
-            # table is a Cucumber::MultilineArgument::DataTable
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'recognises quotes in name and make according regexp' do
-          @step_text = 'A "first" arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'recognises several quoted words in name and make according regexp and args' do
-          @step_text = 'A "first" and "second" arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'does not use quote group when there are no quotes' do
-          @step_text = 'A first arg'
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A first arg$/) do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'is helpful with tables' do
-          @step_text = 'A "first" arg'
-          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1, table|
-            # table is a Cucumber::MultilineArgument::DataTable
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-
-        it 'is helpful with doc string' do
-          @step_text = 'A "first" arg'
-          @multiline_argument = MultilineArgument.from('', Core::Ast::Location.new(''))
-
-          expect(snippet_text).to eq unindented(%{
-          Given(/^A "([^"]*)" arg$/) do |arg1, string|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-
-      describe Snippet::Classic do
-        let(:snippet_class) { Snippet::Classic }
-
-        it 'renders snippet as unwrapped regular expression' do
-          expect(snippet.to_s).to eq unindented(%{
-          Given /^we have a missing step$/ do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-
-      describe Snippet::Percent do
-        let(:snippet_class) { Snippet::Percent }
-
-        it 'renders snippet as percent-style regular expression' do
-          expect(snippet.to_s).to eq unindented(%{
-          Given %r{^we have a missing step$} do
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-
-      describe Snippet::CucumberExpression do
-        let(:snippet_class) { Snippet::CucumberExpression }
-
-        it 'renders snippet as cucumber expression' do
-          @step_text = 'I have 2.3 cukes in my belly'
-          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
-                                            'veg',
-                                            /(cuke|banana)s?/,
-                                            Object,
-                                            ->(s) { s },
-                                            true,
-                                            false
-          ))
-          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
-                                            'cucumis',
-                                            /(bella|cuke)s?/,
-                                            Object,
-                                            ->(s) { s },
-                                            true,
-                                            false
-          ))
-
-          expect(snippet.to_s).to eq unindented(%{
-          Given("I have {float} {cucumis} in my belly") do |float, cucumis|
-          # Given("I have {float} {veg} in my belly") do |float, veg|
-            pending # Write code here that turns the phrase above into concrete actions
-          end
-          })
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/glue/step_definition_spec.rb

@@ -1,207 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/hooks'
-module Cucumber::Hooks
-  shared_examples_for 'a source node' do
-    it 'responds to text' do
-      expect( subject.text ).to be_a(String)
-    end
-
-    it 'responds to location' do
-      expect( subject.location ).to eq(location)
-    end
-
-    it 'responds to match_locations?' do
-      expect( subject.match_locations? [location] ).to be_truthy
-      expect( subject.match_locations? [] ).to be_falsey
-    end
-  end
-
-  require 'cucumber/core/ast/location'
-  describe BeforeHook do
-    subject { BeforeHook.new(location) }
-    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
-    it_behaves_like 'a source node'
-  end
-
-  describe AfterHook do
-    subject { AfterHook.new(location) }
-    let(:location) { Cucumber::Core::Ast::Location.new('hooks.rb', 1) }
-    it_behaves_like 'a source node'
-  end
-end

data/spec/cucumber/multiline_argument/data_table_spec.rb

@@ -1,653 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'spec_helper'
-require 'cucumber/multiline_argument/data_table'
-
-module Cucumber
-  module MultilineArgument
-    describe DataTable do
-      before do
-        @table = DataTable.from([
-          %w{one four seven},
-          %w{4444 55555 666666}
-        ])
-      end
-
-      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
-        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
-        # 666666
-        expect( @table.cells_rows[1][2] ).to equal(@table.columns[2][1])
-      end
-
-      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
-        expect( @table.hashes.first[:one] ).to eq '4444'
-      end
-
-      it 'should return the row values in order' do
-        expect( @table.rows.first ).to eq %w{4444 55555 666666}
-      end
-
-      describe '#symbolic_hashes' do
-
-        it 'should covert data table to an array of hashes with symbols as keys' do
-          ast_table = Cucumber::Core::Ast::DataTable.new([['foo', 'Bar', 'Foo Bar'], %w{1 22 333}], nil)
-          data_table = DataTable.new(ast_table)
-          expect(data_table.symbolic_hashes).to eq([{:foo => '1', :bar => '22', :foo_bar => '333'}])
-        end
-
-        it 'should be able to be accessed multiple times' do
-          @table.symbolic_hashes
-          expect{@table.symbolic_hashes}.to_not raise_error
-        end
-
-        it 'should not interfere with use of #hashes' do
-          @table.symbolic_hashes
-          expect{@table.hashes}.to_not raise_error
-        end
-
-      end
-
-      describe '#map_column!' 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
-          headers = ['header']
-          rows = ['value']
-          table = DataTable.from [headers, rows]
-          count = 0
-          table.map_column!('header') { |value| count +=1 }
-          table.rows
-          expect( count ).to eq rows.size
-        end
-
-        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
-          @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
-          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
-          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
-          expect( (@table.map_column!(:one) { |v| v.to_i }) ).to eq @table
-        end
-      end
-
-      describe '#map_column' 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
-          headers = ['header']
-          rows = ['value']
-          table = DataTable.from [headers, rows]
-          count = 0
-          new_table = table.map_column('header') { |value| count +=1 }
-          new_table.rows
-          expect( count ).to eq rows.size
-        end
-
-        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
-          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
-          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
-          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
-          expect( (@table.map_column(:one) { |v| v.to_i }) ).to_not eq @table
-        end
-      end
-
-      describe '#match' do
-        before(:each) do
-          @table = DataTable.from([
-            %w{one four seven},
-            %w{4444 55555 666666}
-          ])
-        end
-
-        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
-          expect( @table.match('table:one,four,seven') ).to_not be_nil
-        end
-        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
-        before(:each) do
-          @table = DataTable.from([
-            %w{one 1111},
-            %w{two 22222}
-          ])
-        end
-
-        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
-
-        it 'should return a hash of the rows' do
-          table = DataTable.from([
-            %w{one 1111},
-            %w{two 22222}
-          ])
-          expect( table.rows_hash ).to eq( 'one' => '1111', 'two' => '22222' )
-        end
-
-        it "should fail if the table doesn't have two columns" do
-          faulty_table = DataTable.from([
-            %w{one 1111 abc},
-            %w{two 22222 def}
-          ])
-          expect {
-            faulty_table.rows_hash
-          }.to raise_error('The table must have exactly 2 columns')
-        end
-
-        it 'should support header and column mapping' do
-          table = DataTable.from([
-            %w{one 1111},
-            %w{two 22222}
-          ])
-          t2 = table.map_headers({ 'two' => 'Two' }) { |header| header.upcase }.
-                     map_column('two', false) { |val| val.to_i }
-          expect( t2.rows_hash ).to eq( 'ONE' => '1111', 'Two' => 22222 )
-        end
-      end
-
-      describe '#map_headers!' do
-        let(:table) do
-          DataTable.from([
-          %w{HELLO WORLD},
-          %w{4444 55555}
-          ])
-        end
-
-        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
-          @table.map_headers!(/one|uno/ => :three)
-          expect( @table.hashes.first[:three] ).to eq '4444'
-        end
-
-        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
-          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
-          table.map_headers!('WORLD' => 'foo') do |header|
-            header.downcase
-          end
-
-          expect( table.hashes.first.keys ).to match %w[hello foo]
-        end
-      end
-
-      describe '#map_headers' do
-        let(:table) do
-           DataTable.from([
-          %w{HELLO WORLD},
-          %w{4444 55555}
-          ])
-        end
-
-        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
-          table2 = @table.map_headers(/one|uno/ => :three)
-          expect( table2.hashes.first[:three] ).to eq '4444'
-        end
-
-        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
-          table2 = table.map_headers do |header|
-            header.downcase
-          end
-
-          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
-          table2 = table.map_headers('WORLD' => 'foo') do |header|
-            header.downcase
-          end
-
-          expect( table2.hashes.first.keys ).to match %w[hello foo]
-        end
-      end
-
-      describe 'diff!' do
-        it 'should detect a complex diff' do
-          t1 = DataTable.from(%{
-            | 1         | 22          | 333         | 4444         |
-            | 55555     | 666666      | 7777777     | 88888888     |
-            | 999999999 | 0000000000  | 01010101010 | 121212121212 |
-            | 4000      | ABC         | DEF         | 50000        |
-          })
-
-          t2 = DataTable.from(%{
-            | a     | 4444     | 1         |
-            | bb    | 88888888 | 55555     |
-            | ccc   | xxxxxxxx | 999999999 |
-            | dddd  | 4000     | 300       |
-            | e     | 50000    | 4000      |
-          })
-          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
-          t = DataTable.from(%{
-            |a|b|c|
-            |d|e|f|
-            |g|h|i|
-          })
-          t.diff!(t.dup)
-          expect( t.to_s(:indent => 12, :color => false) ).to eq %{
-            |     a |     b |     c |
-            |     d |     e |     f |
-            |     g |     h |     i |
-          }
-        end
-
-        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|
-            |g|h|i|
-                               })
-            t.diff!(t.dup)
-            expect( t.to_s(:indent => 12, :color => false) ).to eq %{
-            |     a |     a |     c |
-            |     d |     e |     f |
-            |     g |     h |     i |
-          }
-          end
-
-          it 'detects a diff in one cell' do
-            t1 = DataTable.from(%{
-            |a|a|c|
-            |d|e|f|
-            |g|h|i|
-                                })
-            t2 = DataTable.from(%{
-            |a|a|c|
-            |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
-            t1 = DataTable.from(%{
-            |a|a|b|c|
-            |d|d|e|f|
-            |g|g|h|i|
-                                })
-            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 | (-) a |     b |     c |
-                |     d | (-) d |     e |     f |
-                |     g | (-) g |     h |     i |
-              }
-            end
-          end
-
-          it 'detects surplus columns' do
-            t1 = DataTable.from(%{
-            |a|b|c|
-            |d|e|f|
-            |g|h|i|
-                                })
-            t2 = DataTable.from(%{
-            |a|b|a|c|
-            |d|e|d|f|
-            |g|h|g|i|
-                                })
-            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
-          t1 = DataTable.from([
-            %w(name  male lastname swedish),
-            %w(aslak true hellesøy false)
-          ])
-          t2 = DataTable.from([
-            %w(name    male   lastname   swedish),
-            ['aslak', true, 'hellesøy', 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
-          t1 = DataTable.from([
-            %w(name  male),
-            %w(aslak true)
-          ])
-          t1.map_column!('male') { |m| m == 'true' }
-          t2 = DataTable.from([
-            %w(name    male),
-            ['aslak', true]
-          ])
-          t1.diff!(t2)
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     name  |     male |
-            |     aslak |     true |
-          }
-        end
-
-        it 'should allow column mapping of argument before diffing' do
-          t1 = DataTable.from([
-            %w(name    male),
-            ['aslak', true]
-          ])
-          t1.map_column!('male') {
-            'true'
-          }
-          t2 = DataTable.from([
-            %w(name  male),
-            %w(aslak true)
-          ])
-          t2.diff!(t1)
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     name  |     male |
-            |     aslak |     true |
-          }
-        end
-
-        it 'should allow header mapping before diffing' do
-          t1 = DataTable.from([
-            %w(Name  Male),
-            %w(aslak true)
-          ])
-          t1.map_headers!('Name' => 'name', 'Male' => 'male')
-          t1.map_column!('male') { |m| m == 'true' }
-          t2 = DataTable.from([
-            %w(name    male),
-            ['aslak', true]
-          ])
-          t1.diff!(t2)
-          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
-            |     name  |     male |
-            |     aslak |     true |
-          }
-        end
-
-        it 'should detect seemingly identical tables as different' do
-          t1 = DataTable.from([
-            %w(X Y),
-            %w(2 1)
-          ])
-          t2 = DataTable.from([
-            %w(X  Y),
-            [2, 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
-          t1 = DataTable.from([
-            %w(Cuke Duke),
-            %w(Foo  Bar)
-          ])
-          expect do
-            t1.map_headers!(/uk/ => 'u')
-            t1.hashes
-          end.to raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
-        end
-
-        describe 'raising' do
-          before do
-            @t = DataTable.from(%{
-              | a | b |
-              | c | d |
-            })
-            expect( @t ).not_to eq nil
-          end
-
-          it 'should raise on missing rows' do
-            t = DataTable.from(%{
-              | a | b |
-            })
-            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
-            t = DataTable.from(%{
-              | a | b |
-              | c | d |
-              | e | f |
-            })
-            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
-            t1 = DataTable.from(%{
-              | row_1 | row_2 |
-              | four  | 4     |
-            })
-            t2 = DataTable.from(%{
-              | row_1 | row_2 |
-              | one   | 1     |
-              | two   | 2     |
-              | three | 3     |
-              | four  | 4     |
-              | five  | 5     |
-            })
-            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
-            t = DataTable.from(%{
-              | a |
-              | c |
-            })
-            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
-            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(DataTable::Different)
-          end
-
-          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(DataTable::Different)
-          end
-        end
-
-        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 '#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  |
-            |     true |     aslak |
-          }
-        end
-      end
-    end
-  end
-end