cucumber 2.99.0 → 3.0.0

data/spec/cucumber/formatter/progress_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/progress'
@@ -12,15 +13,15 @@ module Cucumber
       before(:each) do
         Cucumber::Term::ANSIColor.coloring = false
         @out = StringIO.new
-        @formatter = Progress.new(runtime, @out, Cucumber::Cli::Options.new)
+        @formatter = Progress.new(actual_runtime.configuration.with_options(out_stream: @out))
       end
 
-      describe "given a single feature" do
+      describe 'given a single feature' do
         before(:each) do
           run_defined_feature
         end
 
-        describe "with a scenario" do
+        describe 'with a scenario' do
           define_feature <<-FEATURE
             Feature: Banana party
 
@@ -28,12 +29,12 @@ module Cucumber
                 Given there are bananas
           FEATURE
 
-          it "outputs the undefined step" do
+          it 'outputs the undefined step' do
             expect(@out.string).to include "U\n"
           end
         end
 
-        describe "with a background" do
+        describe 'with a background' do
           define_feature <<-FEATURE
             Feature: Banana party
 
@@ -44,12 +45,12 @@ module Cucumber
                 Given there are bananas
           FEATURE
 
-          it "outputs the two undefined steps" do
+          it 'outputs the two undefined steps' do
             expect(@out.string).to include "UU\n"
           end
         end
 
-        describe "with a scenario outline" do
+        describe 'with a scenario outline' do
           define_feature <<-FEATURE
             Feature: Fud Pyramid
 
@@ -66,23 +67,23 @@ module Cucumber
                  | carrots  |
           FEATURE
 
-          it "outputs each undefined step" do
+          it 'outputs each undefined step' do
             expect(@out.string).to include "UUUU\n"
           end
 
-          it "has 4 undefined scenarios" do
-            expect(@out.string).to include "4 scenarios (4 undefined)"
+          it 'has 4 undefined scenarios' do
+            expect(@out.string).to include '4 scenarios (4 undefined)'
           end
 
-          it "has 4 undefined steps" do
-            expect(@out.string).to include "4 steps (4 undefined)"
+          it 'has 4 undefined steps' do
+            expect(@out.string).to include '4 steps (4 undefined)'
           end
 
         end
 
-        describe "with hooks" do
+        describe 'with hooks' do
 
-          describe "all hook passes" do
+          describe 'all hook passes' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -99,7 +100,7 @@ module Cucumber
               Given(/^this step passes$/) {}
             end
 
-            it "only steps generate output" do
+            it 'only steps generate output' do
               lines = <<-OUTPUT
               .
               1 scenario (1 passed)
@@ -111,7 +112,7 @@ module Cucumber
             end
           end
 
-          describe "with a failing before hook" do
+          describe 'with a failing before hook' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -120,12 +121,12 @@ module Cucumber
 
             define_steps do
               Before do
-                fail "hook failed" 
+                fail 'hook failed'
               end
               Given(/^this step passes$/) {}
             end
 
-            it "the failing hook generate output" do
+            it 'the failing hook generate output' do
               lines = <<-OUTPUT
               F-
               1 scenario (1 failed)
@@ -137,7 +138,7 @@ module Cucumber
             end
           end
 
-          describe "with a failing after hook" do
+          describe 'with a failing after hook' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -146,12 +147,12 @@ module Cucumber
 
             define_steps do
               After do
-                fail "hook failed" 
+                fail 'hook failed'
               end
               Given(/^this step passes$/) {}
             end
 
-            it "the failing hook generate output" do
+            it 'the failing hook generate output' do
               lines = <<-OUTPUT
               .F
               1 scenario (1 failed)

data/spec/cucumber/formatter/rerun_spec.rb

@@ -1,90 +1,96 @@
+# frozen_string_literal: true
 require 'cucumber/formatter/rerun'
 require 'cucumber/core'
 require 'cucumber/core/gherkin/writer'
 require 'cucumber/core/filter'
 require 'support/standard_step_actions'
-
-module Cucumber::Formatter
-  describe Rerun do
-    include Cucumber::Core::Gherkin::Writer
-    include Cucumber::Core
-
-    # after_test_case
-    context 'when 2 scenarios fail in the same file' do
-      it 'Prints the locations of the failed scenarios' do
-        gherkin = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'failing'
-            end
-
-            scenario do
-              step 'failing'
-            end
-
-            scenario do
-              step 'passing'
+require 'cucumber/configuration'
+
+module Cucumber
+  module Formatter
+    describe Rerun do
+      include Cucumber::Core::Gherkin::Writer
+      include Cucumber::Core
+
+      let(:config) { Cucumber::Configuration.new(out_stream: io) }
+      let(:io) { StringIO.new }
+
+      # after_test_case
+      context 'when 2 scenarios fail in the same file' do
+        it 'Prints the locations of the failed scenarios' do
+          gherkin = gherkin('foo.feature') do
+            feature do
+              scenario do
+                step 'failing'
+              end
+
+              scenario do
+                step 'failing'
+              end
+
+              scenario do
+                step 'passing'
+              end
             end
           end
-        end
-        io = StringIO.new
-        report = Rerun.new(double, io, {})
-
-        execute [gherkin], report, [StandardStepActions.new]
+          Rerun.new(config)
+          execute [gherkin], [StandardStepActions.new], config.event_bus
+          config.event_bus.test_run_finished
 
-        expect( io.string ).to eq 'foo.feature:3:6'
+          expect( io.string ).to eq 'foo.feature:3:6'
+        end
       end
-    end
 
-    context 'with failures in multiple files' do
-      it 'prints the location of the failed scenarios in each file' do
-        foo = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'failing'
-            end
-
-            scenario do
-              step 'failing'
-            end
-
-            scenario do
-              step 'passing'
+      context 'with failures in multiple files' do
+        it 'prints the location of the failed scenarios in each file' do
+          foo = gherkin('foo.feature') do
+            feature do
+              scenario do
+                step 'failing'
+              end
+
+              scenario do
+                step 'failing'
+              end
+
+              scenario do
+                step 'passing'
+              end
             end
           end
-        end
 
-        bar = gherkin('bar.feature') do
-          feature do
-            scenario do
-              step 'failing'
+          bar = gherkin('bar.feature') do
+            feature do
+              scenario do
+                step 'failing'
+              end
             end
           end
-        end
 
-        io = StringIO.new
-        report = Rerun.new(double, io, {})
+          Rerun.new(config)
+          execute [foo, bar], [StandardStepActions.new], config.event_bus
+          config.event_bus.test_run_finished
 
-        execute [foo, bar], report, [StandardStepActions.new]
-
-        expect(io.string).to eq 'foo.feature:3:6 bar.feature:3'
+          expect(io.string).to eq 'foo.feature:3:6\nbar.feature:3'
+        end
       end
-    end
 
-    context 'when there are no failing scenarios' do
-      it 'prints nothing' do
-        gherkin = gherkin('foo.feature') do
-          feature do
-            scenario do
-              step 'passing'
+      context 'when there are no failing scenarios' do
+        it 'prints nothing' do
+          gherkin = gherkin('foo.feature') do
+            feature do
+              scenario do
+                step 'passing'
+              end
             end
           end
-        end
 
-        io = StringIO.new
-        report = Rerun.new(double, io, {})
+          Rerun.new(config)
+          execute [gherkin], [StandardStepActions.new], config.event_bus
+          config.event_bus.test_run_finished
 
-        execute [gherkin], report, [StandardStepActions.new]
+          expect(io.string).to eq ''
+        end
       end
     end
   end

data/spec/cucumber/formatter/spec_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Cucumber
   module Formatter
     module SpecHelperDsl
@@ -21,10 +22,10 @@ module Cucumber
         define_steps
         actual_runtime.visitor = report
 
-        receiver = Test::Runner.new(report)
+        receiver = Test::Runner.new(event_bus)
         filters = [
           Filters::ActivateSteps.new(
-            StepMatchSearch.new(actual_runtime.support_code.ruby.method(:step_matches), actual_runtime.configuration),
+            StepMatchSearch.new(actual_runtime.support_code.registry.method(:step_matches), actual_runtime.configuration),
             actual_runtime.configuration
           ),
           Filters::ApplyAfterStepHooks.new(actual_runtime.support_code),
@@ -34,17 +35,13 @@ module Cucumber
           Filters::PrepareWorld.new(actual_runtime)
         ]
         compile [gherkin_doc], receiver, filters
-      end
-
-      require 'cucumber/formatter/event_bus_report'
-      def event_bus_report
-        @event_bus_report ||= Formatter::EventBusReport.new(actual_runtime.configuration)
+        event_bus.test_run_finished
       end
 
       require 'cucumber/formatter/legacy_api/adapter'
       def report
         @report ||= LegacyApi::Adapter.new(
-          Fanout.new([@formatter, event_bus_report]),
+          Fanout.new([@formatter]),
           actual_runtime.results,
           actual_runtime.configuration)
       end
@@ -55,7 +52,7 @@ module Cucumber
       end
 
       def gherkin
-        self.class.feature_content || raise("No feature content defined!")
+        self.class.feature_content || raise('No feature content defined!')
       end
 
       def runtime
@@ -66,11 +63,16 @@ module Cucumber
         @runtime ||= Runtime.new(options)
       end
 
+      def event_bus
+        actual_runtime.configuration.event_bus
+      end
+
       def define_steps
-        return unless step_defs = self.class.step_defs
-        rb = runtime.support_code.ruby
+        step_defs = self.class.step_defs
+
+        return unless step_defs
         dsl = Object.new
-        dsl.extend RbSupport::RbDsl
+        dsl.extend Glue::Dsl
         dsl.instance_exec &step_defs
       end
 

data/spec/cucumber/{rb_support/rb_world_spec.rb → glue/proto_world_spec.rb}

@@ -1,14 +1,30 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/pretty'
 
 module Cucumber
-  module RbSupport
-    describe RbWorld do
-      extend Cucumber::Formatter::SpecHelperDsl
-      include Cucumber::Formatter::SpecHelper
+  module Glue
+    describe ProtoWorld do
+
+      let(:runtime) { double('runtime') }
+      let(:language) { double('language') }
+      let(:world) { Object.new.extend(ProtoWorld.for(runtime, language)) }
+
+      describe '#table' do
+        it 'produces Ast::Table by #table' do
+          expect(world.table(%{
+        | account | description | amount |
+        | INT-100 | Taxi        | 114    |
+        | CUC-101 | Peeler      | 22     |
+          })).to be_kind_of(MultilineArgument::DataTable)
+        end
+      end
 
       describe 'Handling puts in step definitions' do
+        extend Cucumber::Formatter::SpecHelperDsl
+        include Cucumber::Formatter::SpecHelper
+
         before(:each) do
           Cucumber::Term::ANSIColor.coloring = false
           @out = StringIO.new
@@ -26,7 +42,7 @@ module Cucumber
 
           define_steps do
             When(/^puts is called twice for the same variable$/) do
-              foo = 'a'
+              foo = String.new('a')
               puts foo
               foo.upcase!
               puts foo
@@ -34,7 +50,7 @@ module Cucumber
           end
 
           it 'prints the variable value at the time puts was called' do
-            expect( @out.string ).to include <<OUTPUT
+            expect(@out.string).to include <<OUTPUT
     When puts is called twice for the same variable
       a
       A

data/spec/cucumber/glue/registry_and_more_spec.rb

@@ -0,0 +1,213 @@
+# 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(:registry)       { support_code.registry }
+      let(:support_code) do
+        Cucumber::Runtime::SupportCode.new(user_interface)
+      end
+      let(:dsl) do
+        registry
+        Object.new.extend(Glue::Dsl)
+      end
+
+      describe '#load_code_file' do
+        after do
+          FileUtils.rm_rf('tmp.rb')
+          FileUtils.rm_rf('docs.md')
+        end
+
+        def a_file_called(name)
+          File.open(name, 'w') do |f|
+            f.puts yield
+          end
+        end
+
+        it 're-loads the file when called multiple times' do
+          a_file_called('tmp.rb') do
+            '$foo = 1'
+          end
+
+          registry.load_code_file('tmp.rb')
+          expect($foo).to eq 1
+
+          a_file_called('tmp.rb') do
+            '$foo = 2'
+          end
+
+          registry.load_code_file('tmp.rb')
+
+          expect($foo).to eq 2
+        end
+
+        it 'only loads ruby files' do
+          a_file_called('docs.md') do
+            'yo'
+          end
+          registry.load_code_file('docs.md')
+        end
+      end
+
+      describe 'Handling the World' do
+        it 'raises an error if the world is nil' do
+          dsl.World {}
+
+          begin
+            registry.begin_scenario(nil)
+            raise 'Should fail'
+          rescue Glue::NilWorld => e
+            expect(e.message).to eq 'World procs should never return nil'
+            expect(e.backtrace.length).to eq 1
+            expect(e.backtrace[0]).to match(/spec\/cucumber\/glue\/registry_and_more_spec\.rb\:\d+\:in `World'/)
+          end
+        end
+
+        module ModuleOne
+        end
+
+        module ModuleTwo
+        end
+
+        class ClassOne
+        end
+
+        it 'implicitlys extend world with modules' do
+          dsl.World(ModuleOne, ModuleTwo)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+
+            expect(included_modules.inspect).to match(/ModuleOne/) # Workaround for RSpec/Ruby 1.9 issue with namespaces
+            expect(included_modules.inspect).to match(/ModuleTwo/)
+          end
+          expect(registry.current_world.class).to eq Object
+        end
+
+        it 'raises error when we try to register more than one World proc' do
+          expected_error = %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/glue/registry_and_more_spec.rb:\\d+:in `World'
+spec/cucumber/glue/registry_and_more_spec.rb:\\d+:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::Glue::Dsl#World RDoc
+or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
+
+}
+          dsl.World { Hash.new }
+
+          expect(-> {
+            dsl.World { Array.new }
+          }).to raise_error(Glue::MultipleWorld, /#{expected_error}/)
+        end
+      end
+
+      describe 'Handling namespaced World' do
+        module ModuleOne
+          def method_one
+            1
+          end
+        end
+
+        module ModuleMinusOne
+          def method_one
+            -1
+          end
+        end
+
+        module ModuleTwo
+          def method_two
+            2
+          end
+        end
+
+        module ModuleThree
+          def method_three
+            3
+          end
+        end
+
+        it 'extends the world with namespaces' do
+          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+            expect(included_modules.inspect).to match(/ModuleOne/)
+          end
+          expect(registry.current_world.class).to eq Object
+          expect(registry.current_world).to respond_to(:method_one)
+
+          expect(registry.current_world.module_two.class).to eq Object
+          expect(registry.current_world.module_two).to respond_to(:method_two)
+
+          expect(registry.current_world.module_three.class).to eq Object
+          expect(registry.current_world.module_three).to respond_to(:method_three)
+        end
+
+        it 'allows to inspect the included modules' do
+          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.inspect).to match(/ModuleOne/)
+          expect(registry.current_world.inspect).to include('ModuleTwo (as module_two)')
+          expect(registry.current_world.inspect).to include('ModuleThree (as module_three)')
+        end
+
+        it 'merges methods when assigning different modules to the same namespace' do
+          dsl.World(namespace: ModuleOne)
+          dsl.World(namespace: ModuleTwo)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.namespace).to respond_to(:method_one)
+          expect(registry.current_world.namespace).to respond_to(:method_two)
+        end
+
+        it 'resolves conflicts when assigning different modules to the same namespace' do
+          dsl.World(namespace: ModuleOne)
+          dsl.World(namespace: ModuleMinusOne)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.namespace).to respond_to(:method_one)
+          expect(registry.current_world.namespace.method_one).to eql(-1)
+        end
+      end
+
+      describe 'hooks' do
+        it 'finds before hooks' do
+          fish = dsl.Before('@fish'){}
+          meat = dsl.Before('@meat'){}
+
+          scenario = double('Scenario')
+
+          expect(scenario).to receive(:accept_hook?).with(fish) { true }
+          expect(scenario).to receive(:accept_hook?).with(meat) { false }
+          expect(registry.hooks_for(:before, scenario)).to eq [fish]
+        end
+
+        it 'finds around hooks' do
+          a = dsl.Around do |scenario, block|
+          end
+
+          b = dsl.Around('@tag') do |scenario, block|
+          end
+
+          scenario = double('Scenario')
+
+          expect(scenario).to receive(:accept_hook?).with(a) { true }
+          expect(scenario).to receive(:accept_hook?).with(b) { false }
+          expect(registry.hooks_for(:around, scenario)).to eq [a]
+        end
+      end
+    end
+  end
+end