qat-cucumber 6.0.0

data/lib/qat/cucumber/world.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+require 'minitest'
+require 'cucumber'
+require_relative 'version'
+require 'qat/logger'
+
+module QAT
+  module Cucumber
+    #Cucumber World utility. Will be automatically included in the World object when this file is required.
+    #Includes MiniTest and a Logger utility.
+    #In order to define the Logger channel, a World Class should be defined by the user.
+    #Should be required in the env.rb file.
+    module World
+      include QAT::Logger
+      include Minitest::Assertions
+
+      attr_accessor :assertions
+
+      # @!attribute assertions
+      #   @return [Integer] Counter of assertions for Minitest integration.
+      def assertions
+        @assertions ||= 0
+      end
+
+      def test_id
+        QAT[:current_test_id]
+      end
+
+      def test_run_id
+        QAT[:current_test_run_id]
+      end
+
+      def evidence_prefix
+        QAT[:current_test_run_id]
+      end
+
+    end
+  end
+end
+

data/lib/qat/cucumber.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+require 'minitest'
+require 'cucumber'
+require_relative 'cucumber/version'
+require_relative 'cucumber/core_ext'
+require 'qat/logger'
+require 'qat/core'
+require 'qat/configuration'
+require 'qat/time'
+require_relative 'jenkins' if ENV['JENKINS_URL']
+require_relative 'cucumber/logger'
+require_relative 'cucumber/time'
+
+require_relative 'cucumber/hooks'
+require_relative 'cucumber/world'
+World QAT::Cucumber::World
+
+#QAT Module works as a namespace for all sub modules.
+#Some singleton methods are also available, as defined by various sub classes.
+#@since 0.1.0
+module QAT
+  # Namespace for various helpers when running with cucumber.
+  #Just require 'qat/cucumber' to automatically integrate all the available helpers.
+  #
+  #@since 0.1.0
+  module Cucumber
+    include QAT::Logger
+
+    class << self
+      include QAT::Cucumber::Logger
+      include QAT::Cucumber::Time
+
+      # Launches the pre-test configurations and integrations
+      # This includes:
+      # - Time Synchronization between the host running tests
+      #   and a target host (test environment?) if configured
+      # - Setups the Jenkins integration if running this CI Server
+      def launch!
+        current_configuration = QAT.configuration
+
+        raise EmptyConfiguration.new "No valid configuration exists to run tests!" unless current_configuration
+        raise InvalidConfiguration.new "No valid environment is defined, aborting test execution!" unless current_configuration.environment
+
+        config_logger(current_configuration)
+
+        time_sync if current_configuration[:time]
+
+        setup_jenkins((current_configuration)) if ENV['JENKINS_URL']
+      end
+
+      private
+
+      # Initializes the Jenkins configuration for test run
+      # @param configuration [Hash] configuration
+      def setup_jenkins(configuration)
+        jenkins_vars = configuration.dig(:jenkins, :env_vars)
+
+        if jenkins_vars
+          QAT::Jenkins.register_vars(jenkins_vars)
+        else
+          log.debug { "Configuring Jenkins with default options." }
+          QAT::Jenkins.register_vars
+        end
+      end
+    end
+
+    # This class represents a empty configuration error when there is no configuration available
+    class EmptyConfiguration < StandardError
+    end
+    # This class represents a invalid configuration error when the configuration is not complete
+    class InvalidConfiguration < StandardError
+    end
+  end
+end
+
+QAT::Cucumber.launch!

data/lib/qat/formatter/console.rb

@@ -0,0 +1,101 @@
+require 'fileutils'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'cucumber/gherkin/formatter/escaping'
+require 'qat/logger'
+require_relative 'loggable'
+
+module QAT
+  module Formatter
+    # Formatter to print Feature, Scenario and Step information on the fly. Will use STDOUT by default or a specified
+    # logger configuration channel.
+    #@see QAT::Loggger
+    #@since 0.1.0
+    class Console
+      include ::FileUtils
+      include ::Cucumber::Formatter::Io
+      include ::Cucumber::Gherkin::Formatter::Escaping
+      include QAT::Formatter::Loggable
+      include QAT::Logger
+
+      #@api private
+      def initialize(_, path_or_io, options)
+        @options = options
+
+        check_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]
+          log.info { "Running #{@current_feature.keyword}: \"#{@current_feature.name}\"" }
+          mdc_before_feature! @current_feature.name
+        end
+
+        @current_scenario = test_case.source[1]
+      end
+
+      #@api private
+      def after_feature *_
+        return if @options[:dry_run]
+
+        log.info { "Finished #{@current_feature.keyword}: \"#{@current_feature.name}\"" }
+        @current_feature = nil
+        mdc_after_feature!
+      end
+
+      #@api private
+      def after_test_case step, result
+        return if @options[:dry_run]
+
+        log.error { result.exception } if result.failed?
+
+        log.info { "Finished #{@current_scenario.keyword}: \"#{format_scenario_name step}\" - #{result.to_sym}\n" } if @current_scenario
+      end
+
+      #@api private
+      def before_test_step step
+        return if @options[:dry_run]
+
+        begin_test_step step do |type|
+          case type
+            when :after_step
+              log.info "Step Done!" if @step_running
+            when :before_scenario
+              log.info { "Running #{@current_scenario.keyword}: \"#{format_scenario_name step}\"" }
+            when :before_step
+              log.info "Step Done!\n" if @step_running
+              step_name = "#{step.source.last.keyword}#{step.name}"
+              log.info { "Step \"#{step_name}\"" }
+              mdc_add_step! step_name
+          end
+        end
+      end
+
+      #@api private
+      def puts obj
+        return if @options[:dry_run]
+
+        log.debug { obj }
+      end
+
+      private
+      def format_scenario_name step
+        return '' unless @current_scenario
+        outline_number, outline_example = nil, nil
+        scenario_name                   = if @current_scenario.is_a? ::Cucumber::Core::Ast::ScenarioOutline
+                                            outline_example = step.source[3].values
+                                            outline_number  = calculate_outline_id(step)
+                                            "#{@current_scenario.name} ##{outline_number}"
+                                          else
+                                            @current_scenario.name
+                                          end
+        mdc_before_scenario! @current_scenario.name, tags_from_test_step(step), outline_number, outline_example
+        return scenario_name
+      end
+    end
+  end
+end

data/lib/qat/formatter/dashboard.rb

@@ -0,0 +1,84 @@
+require 'fileutils'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'cucumber/gherkin/formatter/escaping'
+require 'qat/logger'
+require_relative 'loggable'
+
+module QAT
+  module Formatter
+    # Formatter to send error information to a Dashboard server. Output should be configured in the logger file.
+    #@see QAT::Loggger
+    #@since 0.1.0
+    class Dashboard
+      include ::FileUtils
+      include ::Cucumber::Formatter::Io
+      include ::Cucumber::Gherkin::Formatter::Escaping
+      include QAT::Formatter::Loggable
+      include QAT::Logger
+
+      #@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
+      end
+
+      # #@api private
+      # def exception e, _
+      #   log.error e
+      # end
+    end
+  end
+end

data/lib/qat/formatter/loggable/mdc.rb

@@ -0,0 +1,74 @@
+require 'qat/logger'
+require_relative 'scenario_info'
+
+module QAT
+  module Formatter
+    module Loggable
+      #Helper module to manage loggable mdc information
+      #@since 2.0.2
+      module Mdc
+        include ScenarioInfo
+
+        #Set the MDC key 'feature' with the given value.
+        #@param feature_name [String] Name of the current feature
+        #@since 0.1.0
+        def mdc_before_feature!(feature_name)
+          Log4r::MDC.put 'feature', feature_name
+        end
+
+        #Remove the MDC key 'feature'.
+        #@since 0.1.0
+        def mdc_after_feature!
+          Log4r::MDC.remove 'feature'
+        end
+
+        #Set the MDC key 'scenario' with the given value.
+        #Optionally scenario outline data can also be provided
+        #@param scenario_name [String] Name of the current feature
+        #@param tags [Array<String>] List of tags
+        #@param outline_number [Integer] Number of the current scenario outline
+        #@param outline_example [Array<String>] Values of the current outline's example row
+        #@since 0.1.0
+        def mdc_before_scenario!(scenario_name, tags, outline_number = nil, outline_example = nil)
+          mdc_reset_scenario!
+          Log4r::MDC.put 'scenario', scenario_name
+
+          test_id = test_id(tags, outline_number)
+          Log4r::MDC.put 'test_id', test_id
+          loggable_tags = tags.reject { |tag| tag.match(/^\@test\#/) }
+          Log4r::MDC.put 'tags', loggable_tags
+
+          Log4r::MDC.put 'outline_number', outline_number if outline_number
+          Log4r::MDC.put 'outline_example', outline_example if outline_example
+        end
+
+        #Remove the MDC key 'scenario'. Other options set in #mdc_before_scenario! will also be unset.
+        #@since 0.1.0
+        def mdc_reset_scenario!
+          mdc_remove_step!
+          Log4r::MDC.remove 'scenario'
+          Log4r::MDC.remove 'tags'
+          Log4r::MDC.remove 'outline_number'
+          Log4r::MDC.remove 'outline_example'
+        end
+
+        #Set the MDC key 'step' with the given value.
+        #@param step_name [String] Name of the current step
+        #@since 0.1.0
+        def mdc_add_step!(step_name)
+          Log4r::MDC.put 'step', step_name
+        end
+
+        #Remove the MDC key 'step'.
+        #@since 0.1.0
+        def mdc_remove_step!
+          Log4r::MDC.remove 'step'
+        end
+
+        def mdc_add_status_failed!
+          Log4r::MDC.put 'status', 'failed'
+        end
+      end
+    end
+  end
+end

data/lib/qat/formatter/loggable/scenario_info.rb

@@ -0,0 +1,40 @@
+require 'qat/logger'
+
+module QAT
+  module Formatter
+    module Loggable
+      #Helper module to manage loggable scenario information
+      #@since 2.0.2
+      module ScenarioInfo
+        protected
+
+        def tags_from_test_step(step)
+          step.source.inject([]) do |sum, current_source|
+            sum << current_source.tags if current_source.respond_to? :tags
+            sum
+          end.flatten.map(&:name)
+        end
+
+        def test_id(tags, outline_id)
+          tag = tags.select { |tag| tag.match /^\@test\#\d+$/ }.first
+          if tag
+            id = tag.gsub '@test#', 'test_'
+            id << ".#{outline_id}" if outline_id
+            id
+          else
+            nil
+          end
+        end
+
+        def calculate_outline_id(step)
+          source            = step.source
+          tables            = source[1].instance_exec { @examples_tables }
+          table_lines       = tables.each.map { |line| line.example_rows.size }
+          table_num         = tables.index source[2]
+          previous_outlines = table_lines[0...table_num].inject(0) { |sum, lines| sum += lines; sum }
+          "#{previous_outlines + source[3].number}".to_i
+        end
+      end
+    end
+  end
+end

data/lib/qat/formatter/loggable.rb

@@ -0,0 +1,92 @@
+require 'qat/logger'
+require_relative 'loggable/mdc'
+
+module QAT
+  #Namespace for custom Cucumber formatters and helpers.
+  #@since 0.1.0
+  module Formatter
+    #Helper module to manage formatters based on QAT::Logger
+    #@since 0.1.0
+    module Loggable
+      include QAT::Logger
+      include Mdc
+
+      def check_outputter name
+        return if name.respond_to? :write #Is an IO
+
+        add_outputter_with name
+      end
+
+
+      def ensure_outputter name
+        raise ArgumentError.new "No outputter configured for formatter #{self.class.name}" if name.respond_to? :write
+
+        add_outputter_with name
+      end
+
+      #Parses a test step and determines it's type: after step, before scenario or before step.
+      #Allows a block to be used to execute in the middle of the processing
+      #@param step [Cucumber::Core::Test::Step] Step to parse
+      #@yield [type] Block to execute in the middle of processing
+      #@yieldparam [Symbol] type Type of the test step
+      #@return [Symbol] type Type of the test step
+      #@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"
+
+        #Hooks: step.location = /home/mgomes/Projects/qat/src/qat/lib/qat/cucumber/hooks.rb:53
+        # step.name = "Before hook"
+
+        #Stepdef: step.location = features/formatter.feature:8
+        # step.name = step name
+
+        type = set_type(step)
+
+        yield type if block_given? and type
+
+        set_step_status(type)
+
+        type
+      end
+
+      private
+
+      def add_outputter_with(name)
+        require_relative '../cucumber'
+
+        outputter = Log4r::Outputter[name]
+
+        raise ArgumentError.new "No outputter in loaded configuration file with name #{name}" unless outputter
+
+        return if log.outputters.map(&:name).include? name
+
+        log.add outputter
+      end
+
+      def set_type(step)
+        location  = step.location.file.to_s
+        step_name = step.name
+
+        if step_name == "After hook"
+          :after_step
+        elsif step_name == "Before hook" and location.end_with? 'prepare_world.rb'
+          @current_scenario = step.source[1]
+          :before_scenario
+        elsif File.extname(location.to_s) == '.feature'
+          :before_step
+        end
+      end
+
+      def set_step_status(type)
+        if type == :after_step
+          @step_running = false
+        elsif type == :before_scenario
+          @step_running = false
+        elsif type == :before_step
+          @step_running = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'cucumber/formatter/io'
+require 'json'
+
+module QAT
+  module Formatter
+    module Scenario
+      class Name
+        include Cucumber::Formatter::Io
+
+        def initialize(runtime, path_or_io, options)
+          @runtime   = runtime
+          @io        = ensure_io(path_or_io)
+          @to_file   = (@io != $stdout)
+          @options   = options
+          @scenarios = {}
+          @repeated  = {}
+        end
+
+        def scenario_name(keyword, name, file_colon_line, source_indent)
+          if @to_file
+            if @scenarios.values.include?(name)
+              @repeated[name] ||= []
+              @repeated[name] << file_colon_line
+            end
+            @scenarios[file_colon_line] = name
+          else
+            puts "#{name}: #{file_colon_line}"
+          end
+        end
+
+        def after_features(features)
+          if @to_file
+            content = {
+              scenarios: @scenarios,
+              repeated:  @repeated
+            }
+            @io.puts(content.to_json({
+                                       indent:    ' ',
+                                       space:     ' ',
+                                       object_nl: "\n"
+                                     }))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qat/formatter/tags.rb

@@ -0,0 +1,81 @@
+require 'cucumber/formatter/io'
+require 'json'
+
+module QAT
+  module Formatter
+    # This formatter prints test scenarios tags information to a JSON format.
+    # Information includes:
+    # - untagged test scenarios
+    # - list of unique tags used
+    # - total number of tags used
+    #
+    # Note: Generated test ids are omitted.
+    #
+    class Tags
+      include Cucumber::Formatter::Io
+
+      #@api private
+      def initialize(runtime, path_or_io, options)
+        @io                           = ensure_io(path_or_io)
+        @tags                         = []
+        @scenario_tags                = []
+        @total_scenarios              = 0
+        @total_scenarios_without_tags = 0
+        @scenarios_without_tags       = {}
+        @options                      = options
+      end
+
+      #@api private
+      def after_features(features)
+        publish_result
+      end
+
+      #@api private
+      def before_feature(feature)
+        @feature_tags = []
+        @in_scenarios = false
+      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
+      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
+        @total_scenarios += 1
+        unless scenario_tags.any?
+          @scenarios_without_tags[name] = file_colon_line
+          @total_scenarios_without_tags += 1
+        end
+        @scenario_tags = []
+      end
+
+      private
+      def publish_result
+        content = {
+          untagged: @scenarios_without_tags,
+          tags:
+                    { unique: @tags.uniq.sort,
+                      total:  @tags.size }
+        }
+        @io.puts(content.to_json({
+                                   indent:    ' ',
+                                   space:     ' ',
+                                   object_nl: "\n"
+                                 }))
+      end
+    end
+  end
+end