cucumber 10.2.0 → 11.1.0

data/lib/cucumber/events/test_step_created.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/events'
+require_relative 'base'
 
 module Cucumber
   module Events
     # Event fired when a TestStep is created from a PickleStep
-    class TestStepCreated < Core::Event.new(:test_step, :pickle_step)
+    class TestStepCreated < Base
       attr_reader :test_step, :pickle_step
+
+      def self.event_id
+        :test_step_created
+      end
+
+      def initialize(test_step, pickle_step)
+        @test_step = test_step
+        @pickle_step = pickle_step
+        super()
+      end
     end
   end
 end

data/lib/cucumber/events/test_step_finished.rb

@@ -1,16 +1,26 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/events'
+require_relative 'base'
 
 module Cucumber
   module Events
     # Signals that a {Cucumber::Core::Test::Step} has finished executing
-    class TestStepFinished < Core::Events::TestStepFinished
+    class TestStepFinished < Base
       # @return [Cucumber::Core::Test::Step] the test step that was executed
       attr_reader :test_step
 
       # @return [Cucumber::Core::Test::Result] the result of running the {Cucumber::Core::Test::Step}
       attr_reader :result
+
+      def self.event_id
+        :test_step_finished
+      end
+
+      def initialize(test_step, result)
+        @test_step = test_step
+        @result = result
+        super()
+      end
     end
   end
 end

data/lib/cucumber/events/test_step_started.rb

@@ -1,13 +1,22 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/events'
+require_relative 'base'
 
 module Cucumber
   module Events
     # Signals that a {Cucumber::Core::Test::Step} is about to be executed
-    class TestStepStarted < Core::Events::TestStepStarted
+    class TestStepStarted < Base
       # @return [Cucumber::Core::Test::Step] the test step to be executed
       attr_reader :test_step
+
+      def self.event_id
+        :test_step_started
+      end
+
+      def initialize(test_step)
+        @test_step = test_step
+        super()
+      end
     end
   end
 end

data/lib/cucumber/events/undefined_parameter_type.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/events'
-
 module Cucumber
   module Events
-    class UndefinedParameterType < Core::Event.new(:type_name, :expression)
+    class UndefinedParameterType < Base
       attr_reader :type_name, :expression
+
+      def self.event_id
+        :undefined_parameter_type
+      end
+
+      def initialize(type_name, expression)
+        @type_name = type_name
+        @expression = expression
+        super()
+      end
     end
   end
 end

data/lib/cucumber/events.rb

@@ -34,6 +34,8 @@ module Cucumber
         TestCaseStarted,
         TestCaseReady,
         TestRunFinished,
+        TestRunHookFinished,
+        TestRunHookStarted,
         TestRunStarted,
         TestStepCreated,
         TestStepFinished,

data/lib/cucumber/filters/fire_before_all_hooks.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Filters
+    # Executes all BeforeAll hooks and ONLY if they were all
+    # successful pass on all the `TestCase` objects down the filter chain
+    class FireBeforeAllHooks < Core::Filter.new(:config)
+      def initialize(support_code, receiver = nil)
+        super
+        @support_code = support_code
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        if fire_before_all_hook
+          @test_cases.map do |test_case|
+            test_case.describe_to(@receiver)
+          end
+        end
+        receiver.done
+        self
+      end
+
+      private
+
+      def fire_before_all_hook
+        @support_code.fire_hook(:before_all)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/randomizer.rb

@@ -6,6 +6,9 @@ module Cucumber
   module Filters
     # Batches up all test cases, randomizes them, and then sends them on
     class Randomizer
+      attr_reader :seed
+      private :seed
+
       def initialize(seed, receiver = nil)
         @receiver = receiver
         @test_cases = []
@@ -26,7 +29,7 @@ module Cucumber
       end
 
       def with_receiver(receiver)
-        self.class.new(@seed, receiver)
+        self.class.new(seed, receiver)
       end
 
       private
@@ -34,12 +37,9 @@ module Cucumber
       def shuffled_test_cases
         digester = Digest::SHA2.new(256)
         @test_cases.map.with_index
-                   .sort_by { |_, index| digester.digest((@seed + index).to_s) }
+                   .sort_by { |_, index| digester.digest((seed + index).to_s) }
                    .map { |test_case, _| test_case }
       end
-
-      attr_reader :seed
-      private :seed
     end
   end
 end

data/lib/cucumber/filters/reverser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+module Cucumber
+  module Filters
+    # Reverses the order of test cases
+    class Reverser
+      attr_reader :seed
+      private :seed
+
+      def initialize(receiver = nil)
+        @receiver = receiver
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        reversed_test_cases.each do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(receiver)
+      end
+
+      private
+
+      def reversed_test_cases
+        @test_cases.reverse
+      end
+    end
+  end
+end

data/lib/cucumber/filters.rb

@@ -1,14 +1,3 @@
 # frozen_string_literal: true
 
-require 'cucumber/filters/activate_steps'
-require 'cucumber/filters/apply_after_step_hooks'
-require 'cucumber/filters/apply_before_hooks'
-require 'cucumber/filters/apply_after_hooks'
-require 'cucumber/filters/apply_around_hooks'
-require 'cucumber/filters/broadcast_test_run_started_event'
-require 'cucumber/filters/prepare_world'
-require 'cucumber/filters/quit'
-require 'cucumber/filters/randomizer'
-require 'cucumber/filters/retry'
-require 'cucumber/filters/tag_limits'
-require 'cucumber/filters/broadcast_test_case_ready_event'
+Dir["#{File.dirname(__FILE__)}/filters/*.rb"].map(&method(:require))

data/lib/cucumber/formatter/ansicolor.rb

@@ -47,6 +47,8 @@ module Cucumber
     # * <tt>flaky_param</tt>   - defaults to <tt>yellow,bold</tt>
     # * <tt>failed</tt>        - defaults to <tt>red</tt>
     # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>ambiguous</tt>     - defaults to <tt>red</tt>
+    # * <tt>abmiguous_param</tt> - defaults to <tt>red,bold</tt>
     # * <tt>passed</tt>        - defaults to <tt>green</tt>
     # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
     # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
@@ -72,6 +74,7 @@ module Cucumber
         'pending' => 'yellow',
         'flaky' => 'yellow',
         'failed' => 'red',
+        'ambiguous' => 'red',
         'passed' => 'green',
         'outline' => 'cyan',
         'skipped' => 'cyan',

data/lib/cucumber/formatter/console.rb

@@ -116,11 +116,11 @@ module Cucumber
       def collect_snippet_data(test_step, ast_lookup)
         # collect snippet data for undefined steps
         keyword = ast_lookup.snippet_step_keyword(test_step)
-        @snippets_input << Console::SnippetData.new(keyword, test_step)
+        snippets_input << Console::SnippetData.new(keyword, test_step)
       end
 
       def collect_undefined_parameter_type_names(undefined_parameter_type)
-        @undefined_parameter_types << undefined_parameter_type.type_name
+        undefined_parameter_types << undefined_parameter_type.type_name
       end
 
       def print_snippets(options)
@@ -129,9 +129,9 @@ module Cucumber
         snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
           snippet_text(step_keyword, step_name, multiline_arg)
         end
-        do_print_snippets(snippet_text_proc) unless @snippets_input.empty?
+        do_print_snippets(snippet_text_proc) unless snippets_input.empty?
 
-        @undefined_parameter_types.map do |type_name|
+        undefined_parameter_types.map do |type_name|
           do_print_undefined_parameter_type_snippet(type_name)
         end
       end
@@ -169,7 +169,7 @@ module Cucumber
         end
       end
 
-      def attach(src, media_type, filename)
+      def attach(src, media_type, filename, _streamed_file)
         return unless media_type == 'text/x.cucumber.log+plain'
         return unless @io
 
@@ -249,11 +249,19 @@ module Cucumber
 
       def snippet_text(step_keyword, step_name, multiline_arg)
         keyword = Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip
-        config.snippet_generators.map do |generator|
-          generator.call(keyword, step_name, multiline_arg, config.snippet_type)
+        @config.snippet_generators.map do |generator|
+          generator.call(keyword, step_name, multiline_arg, @config.snippet_type)
         end.join("\n")
       end
 
+      def snippets_input
+        @snippets_input ||= []
+      end
+
+      def undefined_parameter_types
+        @undefined_parameter_types ||= []
+      end
+
       class SnippetData
         attr_reader :actual_keyword, :step
 

data/lib/cucumber/formatter/console_issues.rb

@@ -10,6 +10,7 @@ module Cucumber
       def initialize(config, ast_lookup = AstLookup.new(config))
         @previous_test_case = nil
         @issues = Hash.new { |h, k| h[k] = [] }
+        @global_hooks_summary = GlobalHooksSummary.new(config)
         @config = config
         @config.on_event(:test_case_finished) do |event|
           if event.test_case != @previous_test_case
@@ -24,14 +25,13 @@ module Cucumber
       end
 
       def to_s
-        return if @issues.empty?
-
-        result = Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
-        result.flatten.join("\n")
+        test_case_result = @issues.empty? ? [] : Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
+        global_hooks_result = @global_hooks_summary.ok? ? [] : @global_hooks_summary.exception_listing
+        [test_case_result + global_hooks_result].flatten.join("\n")
       end
 
       def any?
-        @issues.any?
+        @issues.any? || !@global_hooks_summary.ok?
       end
 
       private

data/lib/cucumber/formatter/duration_extractor.rb

@@ -14,6 +14,8 @@ module Cucumber
 
       def failed(*) end
 
+      def ambiguous(*) end
+
       def undefined(*) end
 
       def skipped(*) end

data/lib/cucumber/formatter/fail_fast.rb

@@ -9,11 +9,10 @@ module Cucumber
       def initialize(configuration)
         @previous_test_case = nil
         configuration.on_event :test_case_finished do |event|
-          test_case, result = *event.attributes
-          if test_case != @previous_test_case
+          if event.test_case != @previous_test_case
             @previous_test_case = event.test_case
-            Cucumber.wants_to_quit = true unless result.ok?(strict: configuration.strict)
-          elsif result.passed?
+            Cucumber.wants_to_quit = true unless event.result.ok?(strict: configuration.strict)
+          elsif event.result.passed?
             Cucumber.wants_to_quit = false
           end
         end

data/lib/cucumber/formatter/global_hooks_summary.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
+require 'cucumber/core/test/result'
+require 'cucumber/formatter/ast_lookup'
+
+module Cucumber
+  module Formatter
+    # AllHookSummary formatter, keep track of failures in Before/AfterAll hooks
+    class GlobalHooksSummary
+      include Console
+
+      def initialize(config)
+        @config = config
+        @all_hook_failures = []
+
+        @config.on_event :test_run_hook_finished do |event|
+          @all_hook_failures << event unless event.test_result.ok?
+        end
+      end
+
+      def ok?
+        @all_hook_failures.empty?
+      end
+
+      def exception_listing
+        [format_string('Global hook failures:', :failed)] + @all_hook_failures.map do |event|
+          format_string("#{event.hook.location} # #{event.test_result.exception} (#{event.test_result.exception.class})", :failed)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/html.rb

@@ -7,17 +7,15 @@ require 'cucumber/formatter/message_builder'
 module Cucumber
   module Formatter
     class HTML < MessageBuilder
-      include Io
-
       def initialize(config)
         @io = ensure_io(config.out_stream, config.error_stream)
         @html_formatter = Cucumber::HTMLFormatter::Formatter.new(@io)
         @html_formatter.write_pre_message
-
         super(config)
       end
 
       def output_envelope(envelope)
+        @repository.update(envelope)
         @html_formatter.write_message(envelope)
         @html_formatter.write_post_message if envelope.test_run_finished
       end

data/lib/cucumber/formatter/json.rb

@@ -65,7 +65,8 @@ module Cucumber
       end
 
       def on_test_step_finished(event)
-        test_step, result = *event.attributes
+        test_step = event.test_step
+        result = event.result
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         return if internal_hook?(test_step)
 
@@ -76,7 +77,8 @@ module Cucumber
       def on_test_case_finished(event)
         feature_elements << @test_case_hash if @in_background
 
-        _test_case, result = *event.attributes
+        _test_case = event.test_case
+        result = event.result
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         add_failed_around_hook(result) if result.failed? && !@any_step_failed
       end
@@ -85,7 +87,7 @@ module Cucumber
         @io.write(JSON.pretty_generate(@feature_hashes))
       end
 
-      def attach(src, mime_type, _filename)
+      def attach(src, mime_type, _filename, _streamed_file)
         if mime_type == 'text/x.cucumber.log+plain'
           test_step_output << src
           return

data/lib/cucumber/formatter/junit.rb

@@ -51,19 +51,17 @@ module Cucumber
       end
 
       def on_test_step_finished(event)
-        test_step, result = *event.attributes
         return if @failing_test_step
 
-        @failing_test_step = test_step unless result.ok?(strict: @config.strict)
+        @failing_test_step = event.test_step unless event.result.ok?(strict: @config.strict)
       end
 
       def on_test_case_finished(event)
-        test_case, result = *event.attributes
-        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
-        test_case_name = NameBuilder.new(test_case, @ast_lookup)
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        test_case_name = NameBuilder.new(event.test_case, @ast_lookup)
         scenario = test_case_name.scenario_name
         scenario_designation = "#{scenario}#{test_case_name.name_suffix}"
-        output = create_output_string(test_case, scenario, result, test_case_name.row_name)
+        output = create_output_string(event.test_case, scenario, result, test_case_name.row_name)
         build_testcase(result, scenario_designation, output)
 
         Interceptor::Pipe.unwrap! :stdout
@@ -131,7 +129,7 @@ module Cucumber
       end
 
       def build_testcase(result, scenario_designation, output)
-        duration = ResultBuilder.new(result).test_case_duration
+        duration = DurationExtractor.new(result).result_duration
         @current_feature_data[:time] += duration
         classname = @current_feature_data[:feature].name
         filename = @current_feature_data[:uri]
@@ -234,32 +232,5 @@ module Cucumber
         @name_suffix = " (outline example : #{@row_name})"
       end
     end
-
-    class ResultBuilder
-      attr_reader :test_case_duration
-
-      def initialize(result)
-        @test_case_duration = 0
-        result.describe_to(self)
-      end
-
-      def passed(*) end
-
-      def failed(*) end
-
-      def undefined(*) end
-
-      def skipped(*) end
-
-      def pending(*) end
-
-      def exception(*) end
-
-      def duration(duration, *)
-        duration.tap { |dur| @test_case_duration = dur.nanoseconds / 10**9.0 }
-      end
-
-      def attach(*) end
-    end
   end
 end

data/lib/cucumber/formatter/message.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
 
 require 'cucumber/formatter/io'
-require 'cucumber/formatter/message_builder'
+require 'cucumber/query'
 
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format message</tt>
-    class Message < MessageBuilder
+    class Message
       include Io
 
       def initialize(config)
         @io = ensure_io(config.out_stream, config.error_stream)
-        super(config)
+        @repository = Cucumber::Repository.new
+        @query = Cucumber::Query.new(@repository)
+        config.on_event :envelope, &method(:output_envelope)
       end
 
-      def output_envelope(envelope)
+      def output_envelope(event)
+        envelope = event.envelope
+        @repository.update(envelope)
         @io.write(envelope.to_json)
         @io.write("\n")
       end