cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/formatter/duration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
     module Duration
@@ -6,7 +8,7 @@ module Cucumber
       # <tt>time</tt> format.
       def format_duration(seconds)
         m, s = seconds.divmod(60)
-        "#{m}m#{'%.3f' % s}s"
+        "#{m}m#{format('%<seconds>.3f', seconds: s)}s"
       end
     end
   end

data/lib/cucumber/formatter/duration_extractor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    class DurationExtractor
+      attr_reader :result_duration
+      def initialize(result)
+        @result_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| @result_duration = dur.nanoseconds / 10**9.0 }
+      end
+
+      def embed(*) end
+    end
+  end
+end

data/lib/cucumber/formatter/fail_fast.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+    class FailFast
+      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
+            @previous_test_case = event.test_case
+            Cucumber.wants_to_quit = true unless result.ok?(configuration.strict)
+          elsif result.passed?
+            Cucumber.wants_to_quit = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/fanout.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     # Forwards any messages sent to this object to all recipients
     # that respond to that message.
     class Fanout < BasicObject
@@ -12,6 +13,8 @@ module Cucumber
       end
 
       def method_missing(message, *args)
+        super unless recipients
+
         recipients.each do |recipient|
           recipient.send(message, *args) if recipient.respond_to?(message)
         end
@@ -20,8 +23,6 @@ module Cucumber
       def respond_to_missing?(name, include_private = false)
         recipients.any? { |recipient| recipient.respond_to?(name, include_private) }
       end
-
     end
-
   end
 end

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     class IgnoreMissingMessages < BasicObject
       def initialize(receiver)
         @receiver = receiver
       end
 
       def method_missing(message, *args)
-        @receiver.send(message, *args) if @receiver.respond_to?(message)
+        @receiver.respond_to?(message) ? @receiver.send(message, *args) : super
       end
 
       def respond_to_missing?(name, include_private = false)
         @receiver.respond_to?(name, include_private)
       end
     end
-
   end
 end
-

data/lib/cucumber/formatter/interceptor.rb

@@ -1,4 +1,4 @@
-require 'thread'
+# frozen_string_literal: true
 
 module Cucumber
   module Formatter
@@ -7,20 +7,20 @@ module Cucumber
         attr_reader :pipe
         def initialize(pipe)
           @pipe = pipe
-          @buffer = []
+          @buffer = StringIO.new
           @wrapped = true
         end
 
         def write(str)
-          lock.synchronize do 
+          lock.synchronize do
             @buffer << str if @wrapped
             return @pipe.write(str)
           end
         end
 
-        def buffer
+        def buffer_string
           lock.synchronize do
-            return @buffer.dup
+            return @buffer.string.dup
           end
         end
 
@@ -30,17 +30,15 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk)
+          @pipe.send(method, *args, &blk) || super
         end
 
-        def respond_to?(method, include_private=false)
+        def respond_to_missing?(method, include_private = false)
           super || @pipe.respond_to?(method, include_private)
         end
 
         def self.validate_pipe(pipe)
-          unless [:stdout, :stderr].include? pipe
-            raise ArgumentError, '#wrap only accepts :stderr or :stdout'
-          end
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
         end
 
         def self.unwrap!(pipe)
@@ -62,17 +60,18 @@ module Cucumber
 
           case pipe
           when :stderr
-            $stderr = self.new($stderr)
+            $stderr = new($stderr)
             return $stderr
           when :stdout
-            $stdout = self.new($stdout)
+            $stdout = new($stdout)
             return $stdout
           end
         end
 
-      private
+        private
+
         def lock
-          @lock||=Mutex.new
+          @lock ||= Mutex.new
         end
       end
     end

data/lib/cucumber/formatter/io.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
     module Io
-      def ensure_io(path_or_io, name)
+      module_function
+
+      def ensure_io(path_or_io)
         return nil if path_or_io.nil?
         return path_or_io if path_or_io.respond_to?(:write)
         file = File.open(path_or_io, Cucumber.file_mode('w'))
@@ -15,16 +19,17 @@ module Cucumber
       end
 
       def ensure_file(path, name)
-        raise "You *must* specify --out FILE for the #{name} formatter" unless String === path
+        raise "You *must* specify --out FILE for the #{name} formatter" unless String == path.class
         raise "I can't write #{name} to a directory - it has to be a file" if File.directory?(path)
-        ensure_io(path, name)
+        raise "I can't write #{name} to a file in the non-existing directory #{File.dirname(path)}" unless File.directory?(File.dirname(path))
+        ensure_io(path)
       end
 
       def ensure_dir(path, name)
-        raise "You *must* specify --out DIR for the #{name} formatter" unless String === path
+        raise "You *must* specify --out DIR for the #{name} formatter" unless String == path.class
         raise "I can't write #{name} reports to a file - it has to be a directory" if File.file?(path)
         FileUtils.mkdir_p(path) unless File.directory?(path)
-        path
+        File.absolute_path path
       end
     end
   end

data/lib/cucumber/formatter/json.rb

@@ -1,19 +1,321 @@
-require 'cucumber/formatter/gherkin_formatter_adapter'
+# frozen_string_literal: true
+
+require 'multi_json'
+require 'base64'
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
-require 'gherkin/formatter/argument'
-require 'gherkin/formatter/json_formatter'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format json</tt>
-    class Json < GherkinFormatterAdapter
+    class Json
       include Io
 
-      def initialize(runtime, io, options)
-        @io = ensure_io(io, "json")
-        super(Gherkin::Formatter::JSONFormatter.new(@io), false, options)
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        @ast_lookup = AstLookup.new(config)
+        @feature_hashes = []
+        @step_or_hook_hash = {}
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_step_started, &method(:on_test_step_started)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
+      end
+
+      def on_test_case_started(event)
+        test_case = event.test_case
+        builder = Builder.new(test_case, @ast_lookup)
+        unless same_feature_as_previous_test_case?(test_case)
+          @feature_hash = builder.feature_hash
+          @feature_hashes << @feature_hash
+        end
+        @test_case_hash = builder.test_case_hash
+        if builder.background?
+          @in_background = true
+          feature_elements << builder.background_hash
+          @element_hash = builder.background_hash
+        else
+          @in_background = false
+          feature_elements << @test_case_hash
+          @element_hash = @test_case_hash
+        end
+        @any_step_failed = false
+      end
+
+      def on_test_step_started(event)
+        test_step = event.test_step
+        return if internal_hook?(test_step)
+        if test_step.hook?
+          @step_or_hook_hash = {}
+          hooks_of_type(test_step) << @step_or_hook_hash
+          return
+        end
+        if first_step_after_background?(test_step)
+          @in_background = false
+          feature_elements << @test_case_hash
+          @element_hash = @test_case_hash
+        end
+        @step_or_hook_hash = create_step_hash(test_step)
+        steps << @step_or_hook_hash
+        @step_hash = @step_or_hook_hash
+      end
+
+      def on_test_step_finished(event)
+        test_step, result = *event.attributes
+        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        return if internal_hook?(test_step)
+        add_match_and_result(test_step, result)
+        @any_step_failed = true if result.failed?
+      end
+
+      def on_test_case_finished(event)
+        _test_case, result = *event.attributes
+        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        add_failed_around_hook(result) if result.failed? && !@any_step_failed
+      end
+
+      def on_test_run_finished(_event)
+        @io.write(MultiJson.dump(@feature_hashes, pretty: true))
+      end
+
+      def puts(message)
+        test_step_output << message
+      end
+
+      def embed(src, mime_type, _label)
+        if File.file?(src)
+          content = File.open(src, 'rb', &:read)
+          data = encode64(content)
+        elsif mime_type =~ /;base64$/
+          mime_type = mime_type[0..-8]
+          data = src
+        else
+          data = encode64(src)
+        end
+        test_step_embeddings << { mime_type: mime_type, data: data }
+      end
+
+      private
+
+      def same_feature_as_previous_test_case?(test_case)
+        current_feature[:uri] == test_case.location.file
+      end
+
+      def first_step_after_background?(test_step)
+        @in_background && test_step.location.lines.max >= @test_case_hash[:line]
+      end
+
+      def internal_hook?(test_step)
+        test_step.location.file.include?('lib/cucumber/')
+      end
+
+      def current_feature
+        @feature_hash ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
+      end
+
+      def feature_elements
+        @feature_hash[:elements] ||= []
+      end
+
+      def steps
+        @element_hash[:steps] ||= []
+      end
+
+      def hooks_of_type(hook_step)
+        case hook_step.text
+        when 'Before hook'
+          before_hooks
+        when 'After hook'
+          after_hooks
+        when 'AfterStep hook'
+          after_step_hooks
+        else
+          raise 'Unknown hook type ' + hook_step.to_s
+        end
+      end
+
+      def before_hooks
+        @element_hash[:before] ||= []
+      end
+
+      def after_hooks
+        @element_hash[:after] ||= []
+      end
+
+      def around_hooks
+        @element_hash[:around] ||= []
+      end
+
+      def after_step_hooks
+        @step_hash[:after] ||= []
+      end
+
+      def test_step_output
+        @step_or_hook_hash[:output] ||= []
+      end
+
+      def test_step_embeddings
+        @step_or_hook_hash[:embeddings] ||= []
+      end
+
+      def create_step_hash(test_step)
+        step_source = @ast_lookup.step_source(test_step).step
+        step_hash = {
+          keyword: step_source.keyword,
+          name: test_step.text,
+          line: test_step.location.lines.min
+        }
+        step_hash[:doc_string] = create_doc_string_hash(step_source.doc_string) unless step_source.doc_string.nil?
+        step_hash[:rows] = create_data_table_value(step_source.data_table) unless step_source.data_table.nil?
+        step_hash
+      end
+
+      def create_doc_string_hash(doc_string)
+        content_type = doc_string.content_type || ''
+        {
+          value: doc_string.content,
+          content_type: content_type,
+          line: doc_string.location.line
+        }
+      end
+
+      def create_data_table_value(data_table)
+        data_table.rows.map do |row|
+          { cells: row.cells.map(&:value) }
+        end
+      end
+
+      def add_match_and_result(test_step, result)
+        @step_or_hook_hash[:match] = create_match_hash(test_step, result)
+        @step_or_hook_hash[:result] = create_result_hash(result)
+        result.embeddings.each { |e| embed(e['src'], e['mime_type'], e['label']) } if result.respond_to?(:embeddings)
+      end
+
+      def add_failed_around_hook(result)
+        @step_or_hook_hash = {}
+        around_hooks << @step_or_hook_hash
+        @step_or_hook_hash[:match] = { location: 'unknown_hook_location:1' }
+
+        @step_or_hook_hash[:result] = create_result_hash(result)
+      end
+
+      def create_match_hash(test_step, _result)
+        { location: test_step.action_location.to_s }
+      end
+
+      def create_result_hash(result)
+        result_hash = {
+          status: result.to_sym
+        }
+        result_hash[:error_message] = create_error_message(result) if result.failed? || result.pending?
+        result.duration.tap { |duration| result_hash[:duration] = duration.nanoseconds }
+        result_hash
+      end
+
+      def create_error_message(result)
+        message_element = result.failed? ? result.exception : result
+        message = "#{message_element.message} (#{message_element.class})"
+        ([message] + message_element.backtrace).join("\n")
+      end
+
+      def encode64(data)
+        # strip newlines from the encoded data
+        Base64.encode64(data).delete("\n")
+      end
+
+      class Builder
+        attr_reader :feature_hash, :background_hash, :test_case_hash
+
+        def initialize(test_case, ast_lookup)
+          @background_hash = nil
+          uri = test_case.location.file
+          feature = ast_lookup.gherkin_document(uri).feature
+          feature(feature, uri)
+          background(feature.children.first.background) unless feature.children.first.background.nil?
+          scenario(ast_lookup.scenario_source(test_case), test_case)
+        end
+
+        def background?
+          @background_hash != nil
+        end
+
+        def feature(feature, uri)
+          @feature_hash = {
+            id: create_id(feature.name),
+            uri: uri,
+            keyword: feature.keyword,
+            name: feature.name,
+            description: value_or_empty_string(feature.description),
+            line: feature.location.line
+          }
+          return if feature.tags.empty?
+          @feature_hash[:tags] = create_tags_array_from_hash_array(feature.tags)
+        end
+
+        def background(background)
+          @background_hash = {
+            keyword: background.keyword,
+            name: background.name,
+            description: value_or_empty_string(background.description),
+            line: background.location.line,
+            type: 'background'
+          }
+        end
+
+        def scenario(scenario_source, test_case)
+          scenario = scenario_source.type == :Scenario ? scenario_source.scenario : scenario_source.scenario_outline
+          @test_case_hash = {
+            id: "#{@feature_hash[:id]};#{create_id_from_scenario_source(scenario_source)}",
+            keyword: scenario.keyword,
+            name: test_case.name,
+            description: value_or_empty_string(scenario.description),
+            line: test_case.location.lines.max,
+            type: 'scenario'
+          }
+          @test_case_hash[:tags] = create_tags_array_from_tags_array(test_case.tags) unless test_case.tags.empty?
+        end
+
+        private
+
+        def value_or_empty_string(value)
+          value.nil? ? '' : value
+        end
+
+        def create_id(name)
+          name.downcase.tr(' ', '-')
+        end
+
+        def create_id_from_scenario_source(scenario_source)
+          if scenario_source.type == :Scenario
+            create_id(scenario_source.scenario.name)
+          else
+            scenario_outline_name = scenario_source.scenario_outline.name
+            examples_name = scenario_source.examples.name
+            row_number = calculate_row_number(scenario_source)
+            "#{create_id(scenario_outline_name)};#{create_id(examples_name)};#{row_number}"
+          end
+        end
+
+        def calculate_row_number(scenario_source)
+          scenario_source.examples.table_body.each_with_index do |row, index|
+            return index + 2 if row == scenario_source.row
+          end
+        end
+
+        def create_tags_array_from_hash_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
+          tags_array
+        end
+
+        def create_tags_array_from_tags_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
+          tags_array
+        end
       end
     end
   end
 end
-