cucumber-core 16.2.0 → 17.0.0

data/lib/cucumber/core/test/data_table.rb

@@ -16,60 +16,52 @@ module Cucumber
       #
       # And a matching StepDefinition:
       #
-      #   Given /I have:/ do |table|
+      #   Given('I have:') do |table|
       #     data = table.raw
       #   end
       #
       # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
       #
       class DataTable
-        # Creates a new instance. +raw+ should be an Array of Array of String
-        # or an Array of Hash
+        attr_reader :raw
+
+        # Creates a new instance. +rows+ should be a square (2d), array of strings or an array of hashes
+        #
         # You don't typically create your own DataTable objects - Cucumber will do
         # it internally and pass them to your Step Definitions.
-        #
         def initialize(rows)
           raw = ensure_array_of_array(rows)
           verify_rows_are_same_length(raw)
           @raw = raw.freeze
         end
-        attr_reader :raw
-
-        def describe_to(visitor, *)
-          visitor.data_table(self, *)
-        end
 
-        def to_step_definition_arg
-          dup
+        def ==(other)
+          other.class == self.class && raw == other.raw
         end
 
         def data_table?
           true
         end
 
+        def describe_to(visitor, *)
+          visitor.data_table(self, *)
+        end
+
         def doc_string?
           false
         end
 
         # Creates a copy of this table
-        #
         def dup
           self.class.new(raw.dup)
         end
 
-        # Returns a new, transposed table. Example:
-        #
-        #   | a | 7 | 4 |
-        #   | b | 9 | 2 |
-        #
-        # Gets converted into the following:
-        #
-        #   | a | b |
-        #   | 7 | 9 |
-        #   | 4 | 2 |
-        #
-        def transpose
-          self.class.new(raw.transpose)
+        def inspect
+          %{#<#{self.class} #{raw.inspect}>}
+        end
+
+        def lines_count
+          raw.count
         end
 
         def map(&block)
@@ -80,26 +72,26 @@ module Cucumber
           self.class.new(new_raw)
         end
 
-        def lines_count
-          raw.count
-        end
-
-        def ==(other)
-          other.class == self.class && raw == other.raw
+        def to_step_definition_arg
+          dup
         end
 
-        def inspect
-          %{#<#{self.class} #{raw.inspect})>}
+        # Returns a new, transposed table. Example:
+        #
+        #   | a | 7 | 4 |
+        #   | b | 9 | 2 |
+        #
+        # Gets converted into the following:
+        #
+        #   | a | b |
+        #   | 7 | 9 |
+        #   | 4 | 2 |
+        def transpose
+          self.class.new(raw.transpose)
         end
 
         private
 
-        def verify_rows_are_same_length(raw)
-          raw.transpose
-        rescue IndexError
-          raise ArgumentError, 'Rows must all be the same length'
-        end
-
         def ensure_array_of_array(array)
           array[0].is_a?(Hash) ? hashes_to_array(array) : array
         end
@@ -108,6 +100,12 @@ module Cucumber
           header = hashes[0].keys.sort
           [header] + hashes.map { |hash| header.map { |key| hash[key] } }
         end
+
+        def verify_rows_are_same_length(raw)
+          raw.transpose
+        rescue IndexError
+          raise ArgumentError, 'Rows must all be the same length'
+        end
       end
     end
   end

data/lib/cucumber/core/test/doc_string.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'delegate'
+
 module Cucumber
   module Core
     module Test
@@ -19,7 +20,6 @@ module Cucumber
       # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
       #
       # Note how the indentation from the source is stripped away.
-      #
       class DocString < SimpleDelegator
         attr_reader :content_type, :content
 
@@ -29,47 +29,47 @@ module Cucumber
           super(@content)
         end
 
-        def describe_to(visitor, *)
-          visitor.doc_string(self, *)
+        def ==(other)
+          return false if other.respond_to?(:content_type) && content_type != other.content_type
+          return content == other.to_str if other.respond_to?(:to_str)
+
+          false
         end
 
         def data_table?
           false
         end
 
-        def doc_string?
-          true
+        def describe_to(visitor, *)
+          visitor.doc_string(self, *)
         end
 
-        def map
-          raise ArgumentError, 'No block given' unless block_given?
-
-          new_content = yield content
-          self.class.new(new_content, content_type)
+        def doc_string?
+          true
         end
 
-        def to_step_definition_arg
-          self
+        def inspect
+          [
+            %(#<#{self.class}),
+            %(  """#{content_type}),
+            %(  #{@content}),
+            %(  """>)
+          ].join("\n")
         end
 
         def lines_count
           lines.count + 2
         end
 
-        def ==(other)
-          return false if other.respond_to?(:content_type) && content_type != other.content_type
-          return content == other.to_str if other.respond_to?(:to_str)
+        def map
+          raise ArgumentError, 'No block given' unless block_given?
 
-          false
+          new_content = yield content
+          self.class.new(new_content, content_type)
         end
 
-        def inspect
-          [
-            %(#<#{self.class}),
-            %(  """#{content_type}),
-            %(  #{@content}),
-            %(  """>)
-          ].join("\n")
+        def to_step_definition_arg
+          self
         end
       end
     end

data/lib/cucumber/core/test/empty_multiline_argument.rb

@@ -4,28 +4,28 @@ module Cucumber
   module Core
     module Test
       class EmptyMultilineArgument
-        def describe_to(*)
-          self
-        end
-
         def data_table?
           false
         end
 
+        def describe_to(*)
+          self
+        end
+
         def doc_string?
           false
         end
 
-        def map
-          self
+        def inspect
+          "#<#{self.class}>"
         end
 
         def lines_count
           0
         end
 
-        def inspect
-          "#<#{self.class}>"
+        def map
+          self
         end
       end
     end

data/lib/cucumber/core/test/filters/locations_filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/filter'
+require_relative '../../filter'
 
 module Cucumber
   module Core

data/lib/cucumber/core/test/filters/name_filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/filter'
+require_relative '../../filter'
 
 module Cucumber
   module Core

data/lib/cucumber/core/test/filters/tag_filter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/filter'
+require_relative '../../filter'
 
 module Cucumber
   module Core

data/lib/cucumber/core/test/filters.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/test/filters/locations_filter'
-require 'cucumber/core/test/filters/name_filter'
-require 'cucumber/core/test/filters/tag_filter'
+require_relative 'filters/locations_filter'
+require_relative 'filters/name_filter'
+require_relative 'filters/tag_filter'

data/lib/cucumber/core/test/hook_step.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'cucumber/core/test/step'
+require_relative 'step'
 
 module Cucumber
   module Core

data/lib/cucumber/core/test/location.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'cucumber/core/platform'
 require 'set'
 
 module Cucumber

data/lib/cucumber/core/test/result/ambiguous.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Ambiguous < Raisable
+          include BooleanMethods
+
+          def self.ok?
+            false
+          end
+
+          def describe_to(visitor, *)
+            visitor.ambiguous(*)
+            visitor.duration(duration, *)
+            self
+          end
+
+          def to_s
+            'A'
+          end
+
+          def to_sym
+            :ambiguous
+          end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::AMBIGUOUS,
+              duration: duration.to_message_duration
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/boolean_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        # Simple module that when included generates all the boolean methods for each category of result
+        # The single exception to this is the class method `self.ok?` which is defined for each result individually
+        module BooleanMethods
+          TYPES = %i[failed ambiguous flaky undefined pending skipped passed unknown].freeze
+
+          TYPES.each do |result|
+            define_method("#{result}?") do
+              result == to_sym
+            end
+          end
+
+          def ok?
+            self.class.ok?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/duration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Duration
+          include Cucumber::Messages::Helpers::TimeConversion
+
+          attr_reader :nanoseconds
+
+          def initialize(nanoseconds)
+            @nanoseconds = nanoseconds
+          end
+
+          def to_message_duration
+            duration_hash = seconds_to_duration(nanoseconds.to_f / NANOSECONDS_PER_SECOND)
+            Cucumber::Messages::Duration.new(seconds: duration_hash[:seconds], nanos: duration_hash[:nanos])
+          end
+
+          def seconds_to_duration(seconds_float)
+            seconds, second_modulus = seconds_float.divmod(1)
+            nanos = second_modulus * NANOSECONDS_PER_SECOND
+            { seconds: seconds, nanos: nanos.to_i }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/failed.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Failed
+          include BooleanMethods
+
+          attr_reader :duration, :exception
+
+          def self.ok?
+            false
+          end
+
+          def initialize(duration, exception)
+            raise ArgumentError unless duration
+            raise ArgumentError unless exception
+
+            @duration = duration
+            @exception = exception
+          end
+
+          def describe_to(visitor, *)
+            visitor.failed(*)
+            visitor.duration(duration, *)
+            visitor.exception(exception, *) if exception
+            self
+          end
+
+          def to_s
+            '✗'
+          end
+
+          def to_sym
+            :failed
+          end
+
+          def to_message
+            begin
+              message = exception.backtrace.join("\n")
+            rescue NoMethodError
+              message = ''
+            end
+
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::FAILED,
+              duration: duration.to_message_duration,
+              message: message
+            )
+          end
+
+          def with_duration(new_duration)
+            self.class.new(new_duration, exception)
+          end
+
+          def with_appended_backtrace(step)
+            exception.backtrace << step.backtrace_line if step.respond_to?(:backtrace_line)
+            self
+          end
+
+          def with_filtered_backtrace(filter)
+            self.class.new(duration, filter.new(exception.dup).exception)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/flaky.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        # Flaky is not used directly as an execution result, but is used as a
+        # reporting result type for test cases that fails and the passes on
+        # retry, therefore only the class method self.ok? is needed.
+        class Flaky
+          def self.ok?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/passed.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Passed
+          include BooleanMethods
+
+          attr_accessor :duration
+
+          def self.ok?
+            true
+          end
+
+          def initialize(duration)
+            raise ArgumentError unless duration
+
+            @duration = duration
+          end
+
+          def describe_to(visitor, *)
+            visitor.passed(*)
+            visitor.duration(duration, *)
+            self
+          end
+
+          def to_s
+            '✓'
+          end
+
+          def to_sym
+            :passed
+          end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::PASSED,
+              duration: duration.to_message_duration
+            )
+          end
+
+          def with_appended_backtrace(_step)
+            self
+          end
+
+          def with_filtered_backtrace(_filter)
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/pending.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Pending < Raisable
+          include BooleanMethods
+
+          def self.ok?
+            false
+          end
+
+          def describe_to(visitor, *)
+            visitor.pending(self, *)
+            visitor.duration(duration, *)
+            self
+          end
+
+          def to_s
+            'P'
+          end
+
+          def to_sym
+            :pending
+          end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::PENDING,
+              duration: duration.to_message_duration
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/raisable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        # Base class for exceptions that can be raised in a step definition causing the step to have that result.
+        class Raisable < StandardError
+          attr_reader :message, :duration
+
+          def initialize(message = '', duration = UnknownDuration.new, backtrace = nil)
+            @message = message
+            @duration = duration
+            super(message)
+            set_backtrace(backtrace) if backtrace
+          end
+
+          def with_message(new_message)
+            self.class.new(new_message, duration, backtrace)
+          end
+
+          def with_duration(new_duration)
+            self.class.new(message, new_duration, backtrace)
+          end
+
+          def with_appended_backtrace(step)
+            return self unless step.respond_to?(:backtrace_line)
+
+            set_backtrace([]) unless backtrace
+            backtrace << step.backtrace_line
+            self
+          end
+
+          def with_filtered_backtrace(filter)
+            return self unless backtrace
+
+            filter.new(dup).exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/test/result/skipped.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cucumber/messages'
+require 'cucumber/messages/helpers/time_conversion'
+
+module Cucumber
+  module Core
+    module Test
+      module Result
+        class Skipped < Raisable
+          include BooleanMethods
+
+          def self.ok?
+            true
+          end
+
+          def describe_to(visitor, *)
+            visitor.skipped(*)
+            visitor.duration(duration, *)
+            self
+          end
+
+          def to_s
+            '-'
+          end
+
+          def to_sym
+            :skipped
+          end
+
+          def to_message
+            Cucumber::Messages::TestStepResult.new(
+              status: Cucumber::Messages::TestStepResultStatus::SKIPPED,
+              duration: duration.to_message_duration
+            )
+          end
+        end
+      end
+    end
+  end
+end