qat-cucumber 6.0.0 → 7.0.3

data/lib/qat/formatter/dashboard.rb

@@ -4,6 +4,8 @@ require 'cucumber/formatter/io'
 require 'cucumber/gherkin/formatter/escaping'
 require 'qat/logger'
 require_relative 'loggable'
+require 'cucumber/core/gherkin/writer'
+require_relative 'helper'
 
 module QAT
   module Formatter
@@ -14,71 +16,25 @@ module QAT
       include ::FileUtils
       include ::Cucumber::Formatter::Io
       include ::Cucumber::Gherkin::Formatter::Escaping
+      include ::Cucumber::Core::Gherkin::Writer
       include QAT::Formatter::Loggable
       include QAT::Logger
+      include QAT::Formatter::Helper
 
       #@api private
-      def initialize(_, path_or_io, options)
-        @options = options
-
-        ensure_outputter path_or_io unless options[:dry_run]
-      end
-
-
-      #@api private
-      def before_test_case test_case
-        return if @options[:dry_run]
-
-        unless @current_feature
-          @current_feature = test_case.source[0]
-          mdc_before_feature! @current_feature.name
-        end
-
-        @current_scenario = test_case.source[1]
-      end
-
-      #@api private
-      def after_feature *_
-        return if @options[:dry_run]
-
-        @current_feature = nil
-        mdc_after_feature!
-      end
-
-      #@api private
-      def after_test_case step, passed
-        return if @options[:dry_run]
-
-        if passed.respond_to? :exception
-          mdc_add_step! @step_name
-          mdc_add_status_failed!
-          log.error passed.exception
-        end
-      end
-
-      #@api private
-      def before_test_step step
-        return if @options[:dry_run]
-
-        begin_test_step step do |type|
-          if type == :before_step
-            @step_name = "#{step.source.last.keyword}#{step.name}"
-            mdc_add_step! @step_name
-          elsif :before_scenario
-            outline_number, outline_example = nil, nil
-            if @current_scenario.is_a? ::Cucumber::Core::Ast::ScenarioOutline
-              outline_example = step.source[3].values
-              outline_number  = calculate_outline_id(step)
-            end
-            mdc_before_scenario! @current_scenario.name, tags_from_test_step(step), outline_number, outline_example
-          end
-        end
+      def initialize(config)
+        @config = config
+        @io     = ensure_io(config.out_stream, config.error_stream)
+        ensure_outputter config.out_stream
+        @ast_lookup     = ::Cucumber::Formatter::AstLookup.new(config)
+        @feature_hashes = []
+        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
 
-      # #@api private
-      # def exception e, _
-      #   log.error e
-      # end
     end
   end
 end

data/lib/qat/formatter/helper.rb

@@ -0,0 +1,91 @@
+require_relative 'builder'
+require_relative 'utility_function'
+
+module QAT
+  module Formatter
+    # Helper for Formatters , most of the main methods are done to reduce code duplication
+    module Helper
+      include QAT::Formatter::Builder
+      include QAT::Formatter::UtilityFuction
+
+
+
+      def on_test_case_started event
+        return if @config.dry_run?
+        @row_number = nil
+        test_case   = event.test_case
+        build(test_case, @ast_lookup)
+        assign_print_feature unless @current_feature
+        @current_scenario = @scenario
+        scenario_name     = @current_scenario[:name]
+        print_scenario_start @current_scenario[:keyword], scenario_name
+        mdc_before_scenario! scenario_name, @current_scenario[:tags], @row_number, @examples_values
+      end
+
+
+      def on_test_case_finished event
+        return if @config.dry_run?
+        _test_case, result = *event.attributes
+        @current_feature   = nil
+        if result.failed?
+          mdc_add_step! @mdc_text
+          mdc_add_status_failed!
+          log.error { result.exception }
+        else
+          print_scenario_results @current_scenario[:keyword], @current_scenario[:name], result
+        end
+      end
+
+      def on_test_step_started(event)
+        return if @config.dry_run?
+        test_step = event.test_step
+        return if internal_hook?(test_step)
+        return if support_hook?(test_step)
+        step_source = @ast_lookup.step_source(test_step).step
+        print_assign_step test_step, step_source
+      end
+
+
+      def on_test_step_finished(event)
+        return if @config.dry_run?
+        test_step, result = *event.attributes
+        return if internal_hook?(test_step)
+        return if support_hook?(test_step)
+        log.info "Step Done!"
+      end
+
+      def on_test_run_finished _event
+        return if @config.dry_run?
+        print_scenario_results @feature_hash[:keyword], @feature_hash[:name]
+        mdc_after_feature!
+      end
+
+      def assign_print_feature
+        @current_feature = @feature_hash
+        feature_name     = @current_feature[:name]
+        print_scenario_start @current_feature[:keyword], feature_name
+        mdc_before_feature! feature_name
+      end
+
+
+      def print_assign_step test_step, step_source
+        test_step_text = test_step.text
+        log.info { "Step \"#{test_step_text}\"" }
+        @mdc_text = "#{step_source.keyword}#{test_step_text}"
+        mdc_add_step! @mdc_text
+      end
+
+      def print_scenario_results keyword, name, result = nil
+        if result
+          log.info { "Finished #{keyword}: \"#{name}\" - #{result}\n" }
+        else
+          log.info { "Finished #{keyword}: \"#{name}\"" }
+        end
+      end
+
+      def print_scenario_start keyword, name
+        log.info { "Running #{keyword}: \"#{name}\"" }
+      end
+    end
+  end
+end

data/lib/qat/formatter/loggable.rb

@@ -33,13 +33,13 @@ module QAT
       #@since 0.1.0
       def begin_test_step step
         #World: step.location = /usr/local/rvm/gems/ruby-2.2.3/gems/cucumber-2.0.2/lib/cucumber/filters/prepare_world.rb:27
-        # step.name = "Before hook"
+        # step.to_s = "Before hook"
 
         #Hooks: step.location = /home/mgomes/Projects/qat/src/qat/lib/qat/cucumber/hooks.rb:53
-        # step.name = "Before hook"
+        # step.to_s = "Before hook"
 
         #Stepdef: step.location = features/formatter.feature:8
-        # step.name = step name
+        # step.to_s = step name
 
         type = set_type(step)
 
@@ -66,7 +66,7 @@ module QAT
 
       def set_type(step)
         location  = step.location.file.to_s
-        step_name = step.name
+        step_name = step.to_s
 
         if step_name == "After hook"
           :after_step

data/lib/qat/formatter/scenario/name.rb

@@ -1,46 +1,65 @@
 require 'cucumber/formatter/io'
 require 'json'
+require_relative '../helper'
 
 module QAT
   module Formatter
     module Scenario
       class Name
         include Cucumber::Formatter::Io
+        include QAT::Formatter::Helper
 
-        def initialize(runtime, path_or_io, options)
-          @runtime   = runtime
-          @io        = ensure_io(path_or_io)
-          @to_file   = (@io != $stdout)
-          @options   = options
-          @scenarios = {}
-          @repeated  = {}
+        def initialize(config)
+          @config = config
+          @io     = ensure_io(config.out_stream, config.error_stream)
+          #  @to_file   = (@io != $stdout)
+          @to_file        = @io
+          @scenarios      = {}
+          @repeated       = {}
+          @ast_lookup     = ::Cucumber::Formatter::AstLookup.new(config)
+          @feature_hashes = []
+          config.on_event :test_case_started, &method(:on_test_case_started)
+          config.on_event :test_run_finished, &method(:on_test_run_finished)
         end
 
-        def scenario_name(keyword, name, file_colon_line, source_indent)
+
+        def on_test_case_started event
+          @examples_values = []
+          build(event.test_case, @ast_lookup)
+          @current_feature = @feature_hash
+          scenario_name
+        end
+
+        def scenario_name
           if @to_file
-            if @scenarios.values.include?(name)
-              @repeated[name] ||= []
-              @repeated[name] << file_colon_line
+            if @scenarios.values.include?(@scenario[:name])
+              file_colon_line = "#{@current_feature[:uri]}:#{@scenario[:line]}"
+              unless @scenarios.keys.include?(file_colon_line)
+                @repeated[@scenario[:name]] ||= []
+                @repeated[@scenario[:name]] << "#{@current_feature[:uri]}:#{@scenario[:line]}"
+              end
             end
-            @scenarios[file_colon_line] = name
+            file_colon_line             = "#{@current_feature[:uri]}:#{@scenario[:line]}"
+            @scenarios[file_colon_line] = @scenario[:name]
           else
-            puts "#{name}: #{file_colon_line}"
+            Kernel.puts "#{@scenario[:name]}: #{file_colon_line}"
           end
         end
 
-        def after_features(features)
+        def on_test_run_finished(_event)
           if @to_file
             content = {
               scenarios: @scenarios,
               repeated:  @repeated
             }
-            @io.puts(content.to_json({
-                                       indent:    ' ',
-                                       space:     ' ',
-                                       object_nl: "\n"
-                                     }))
+            @io.write (JSON.pretty_generate(content))
+            @io.flush
           end
         end
+
+
+
+
       end
     end
   end

data/lib/qat/formatter/tags.rb

@@ -1,5 +1,6 @@
 require 'cucumber/formatter/io'
 require 'json'
+require_relative 'helper'
 
 module QAT
   module Formatter
@@ -13,50 +14,47 @@ module QAT
     #
     class Tags
       include Cucumber::Formatter::Io
+      include QAT::Formatter::Helper
 
       #@api private
-      def initialize(runtime, path_or_io, options)
-        @io                           = ensure_io(path_or_io)
+      def initialize(config)
+        @config = config
+        @io     = ensure_io(config.out_stream, config.error_stream)
         @tags                         = []
         @scenario_tags                = []
         @total_scenarios              = 0
         @total_scenarios_without_tags = 0
         @scenarios_without_tags       = {}
-        @options                      = options
+        @ast_lookup     = ::Cucumber::Formatter::AstLookup.new(config)
+        @feature_hashes = []
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
       end
 
-      #@api private
-      def after_features(features)
-        publish_result
-      end
 
-      #@api private
-      def before_feature(feature)
+
+      def on_test_case_started event
         @feature_tags = []
-        @in_scenarios = false
+        @examples_values = []
+        test_case        = event.test_case
+        build(test_case, @ast_lookup)
+        @current_feature = @feature_hash
+        @test_id_tags = true
+        scenario_name
       end
 
-      #@api private
-      def tag_name(tag_name)
-        if @in_scenarios
-          @scenario_tags << tag_name unless tag_name.match(/@test#(\d+)/)
-        else
-          @feature_tags << tag_name
-        end
+      def on_test_run_finished(_event)
+        publish_result
       end
 
-      #@api private
-      def after_tags(tags)
-        @in_scenarios = true unless @in_scenarios
-      end
 
       #@api private
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        scenario_tags    = @scenario_tags + @feature_tags
-        @tags            += scenario_tags
+      def scenario_name
+        scenario_tags    = @scenario[:tags] +  @feature_hash[:tags] if @scenario[:tags] &&  @feature_hash[:tags] rescue nil
+        @tags            += scenario_tags unless scenario_tags.nil?
         @total_scenarios += 1
-        unless scenario_tags.any?
-          @scenarios_without_tags[name] = file_colon_line
+        unless scenario_tags.try(:any?)
+          @scenarios_without_tags[@scenario[:name]] = "#{@current_feature[:uri]}:#{@scenario[:line]}"
           @total_scenarios_without_tags += 1
         end
         @scenario_tags = []
@@ -70,12 +68,11 @@ module QAT
                     { unique: @tags.uniq.sort,
                       total:  @tags.size }
         }
-        @io.puts(content.to_json({
-                                   indent:    ' ',
-                                   space:     ' ',
-                                   object_nl: "\n"
-                                 }))
+        @io.write (JSON.pretty_generate(content))
       end
+
+
+
     end
   end
 end

data/lib/qat/formatter/test_ids.rb

@@ -1,64 +1,74 @@
 require 'cucumber/formatter/io'
 require 'json'
+require_relative 'helper'
 
 module QAT
   module Formatter
-    class TestIds
+    # Formatter to get duplicate test ids and get scenarios untagged
+  class TestIds
       include Cucumber::Formatter::Io
+      include QAT::Formatter::Helper
 
-      def initialize(runtime, path_or_io, options)
-        @io                 = ensure_io(path_or_io)
-        @tags               = []
-        @scenario_tags      = []
+      def initialize(config)
+        @config             = config
         @no_test_id         = {}
         @max_test_id        = 0
         @duplicate_test_ids = {}
         @test_id_mapping    = {}
-        @options            = options
-      end
+        @io                 = ensure_io(config.out_stream, config.error_stream)
+        @ast_lookup         = ::Cucumber::Formatter::AstLookup.new(@config)
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
 
-      def before_feature(feature)
-        @in_scenarios = false
       end
 
-      def tag_name(tag_name)
-        @scenario_tags << tag_name if @in_scenarios
+
+      #@api private
+      def on_test_case_started event
+        @feature_hashes     = []
+        @tags               = []
+        @scenario_tags      = []
+        @examples_values = []
+        build(event.test_case, @ast_lookup)
+        @current_feature = @feature_hash
+        scenario_name
       end
 
-      def after_tags(tags)
-        @in_scenarios = true unless @in_scenarios
+      def on_test_run_finished(_event)
+        publish_result
+        @io.flush
       end
 
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        if @scenario_tags.any? { |tag| tag.match(/@test#(\d+)/) }
-          id           = @scenario_tags.map { |tag| tag.match(/@test#(\d+)/) }.compact.first.captures.first.to_i
+      def scenario_name
+       path = "#{@current_feature[:uri]}:#{@scenario[:line]}"
+       scenario_tags= @scenario[:tags]
+        if scenario_tags.any? { |tag| tag.match(/@test#(\d+)/) }
+          id           = scenario_tags.map { |tag| tag.match(/@test#(\d+)/) }.compact.first.captures.first.to_i
           @max_test_id = id if id > @max_test_id
 
-          test_id_info = { name: name,
-                           path: file_colon_line }
+          test_id_info = { name: @scenario[:name],
+                           path:  path}
 
           if @test_id_mapping[id]
             if @duplicate_test_ids[id]
-              @duplicate_test_ids[id] << test_id_info
+              @duplicate_test_ids[id].find do |dup|
+                @exist = true if dup[:path]== test_id_info[:path]
+              end
+              @duplicate_test_ids[id] << test_id_info unless @exist
             else
-              @duplicate_test_ids[id] = [@test_id_mapping[id], test_id_info]
+              @duplicate_test_ids[id] = [@test_id_mapping[id], test_id_info] unless @test_id_mapping[id][:path] == test_id_info[:path]
             end
           else
             @test_id_mapping[id] = test_id_info
           end
-
         else
-          @no_test_id[name] = file_colon_line unless @scenario_tags.include?('@dummy_test')
+          @no_test_id[@scenario[:name]] = path unless scenario_tags.include?('@dummy_test')
         end
-        @scenario_tags = []
-      end
-
-      def after_features(features)
-        publish_result
-        @io.flush
+        @scenario[:tags] = []
       end
 
       private
+
       def publish_result
         content = {
           max:       @max_test_id,
@@ -79,15 +89,14 @@ module QAT
           ------------------------------------
           #{dups_info.join("\n")}
           TXT
-          puts duplicates_info
+          Kernel.puts duplicates_info
         end
 
-        @io.puts(content.to_json({
-                                   indent:    ' ',
-                                   space:     ' ',
-                                   object_nl: "\n"
-                                 }))
+        @io.write (JSON.pretty_generate(content))
       end
+
+
+
     end
   end
 end