qat-cucumber 6.0.0

data/bin/qat

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+#encoding: utf-8
+
+require 'qat/cli/main'
+QAT::CLI::Main.new(ARGV.dup).execute!

data/lib/qat/cli/generator/project.rb

@@ -0,0 +1,32 @@
+require_relative '../../cucumber/version'
+require 'fileutils'
+
+module QAT::CLI::Generator
+
+  #New project generator
+  # @since 0.1.0
+  class Project
+    include FileUtils
+
+    def initialize stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel
+      @fileutils_output = stdout
+    end
+
+    #Create a new project. Will create a new folder with the project's name.
+    #@param name [String] The new project's name
+    def run! name, opts={}
+
+      raise ArgumentError.new 'No project name given' unless name
+      raise ArgumentError.new "The project '#{name}' already exists" if ::File.directory? name
+
+      mkdir name, opts
+      cp_r ::File.join(::File.dirname(__FILE__), '..', '..', 'project', '.'), name, opts
+      cd name, opts do
+        mkdir_p ::File.join('config', 'common'), opts
+        mkdir_p 'lib', opts
+        mkdir_p 'public', opts
+      end
+
+    end
+  end
+end

data/lib/qat/cli/generator.rb

@@ -0,0 +1,48 @@
+require_relative '../cucumber/version'
+
+module QAT::CLI
+  #Module for the various generators used in the CLI utility
+  # @since 0.1.0
+  module Generator
+    # Creates a new QAT project with a given name
+    # @param name [String] project name
+    def create_project(name)
+      QAT::CLI::Generator::Project.new(@stdin, @stdout, @stderr, @kernel).run! name, @sub_options
+
+      if @options.has_key? :modules
+        FileUtils.cd name, @sub_options do
+          add_modules(@options[:modules])
+        end
+      end
+    end
+
+    # Adds QAT modules to the current project
+    # @param modules [Array] list of modules' names to add
+    def add_modules(modules)
+      missing_modules = modules.reject { |mod| QAT::CLI.has_module? mod }
+
+      if missing_modules.any?
+        raise ArgumentError.new "Module#{missing_modules.size > 1 ? 's' : ''} #{missing_modules.join ','} missing!"
+      end
+
+      modules.each do |module_name|
+        add_module(module_name)
+      end
+    end
+
+    # Adds a QAT module to the current project
+    # @param name [String] name of module to add
+    def add_module(name)
+      @stdout.puts "Adding module #{name}" if @sub_options[:verbose]
+      begin
+        QAT::CLI.add_module name, @stdout, @sub_options
+        @stdout.puts "Module #{name} added to #{Dir.getwd.split(::File::SEPARATOR).last}"
+      rescue => exception
+        @stderr.puts "Error adding module #{name}: #{exception.message}"
+        @exit_code = 1
+      end
+    end
+  end
+end
+
+require_relative 'generator/project'

data/lib/qat/cli/main.rb

@@ -0,0 +1,102 @@
+require_relative '../cli'
+require_relative '../cucumber/version'
+require_relative 'generator'
+require 'optparse'
+require 'fileutils'
+require 'time'
+
+#Main class for the CLI.
+#@since 0.1.0
+class QAT::CLI::Main
+  include QAT::CLI::Generator
+
+  #Initialization from command line
+  def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+    @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+    @options                                 = {}
+    @sub_options                             = {}
+    @exit_code                               = 0
+  end
+
+  #Main entry point for execution
+  def execute!
+    parse_argv!
+
+    handle_options if @options.any?
+
+  rescue ArgumentError, OptionParser::MissingArgument => exception
+    @stderr.puts "Error: #{exception.message}"
+    @exit_code = 1
+  ensure
+    @kernel.exit(exit_code)
+  end
+
+  private
+
+  attr_accessor :exit_code
+
+  def parse_argv!
+    @argv = ['-h'] if @argv.empty?
+
+    opts = OptionParser.new do |parser|
+      parser.banner = 'Usage: qat [OPTIONS]'
+      # parser.separator ''
+      parser.separator 'Options'
+
+      project_options(parser)
+    end
+
+    opts.parse!(@argv)
+  end
+
+  def handle_options
+    if @options.has_key? :project
+      create_project(@options[:project])
+    elsif @options.has_key? :modules
+      add_modules(@options[:modules])
+    end
+  end
+
+  def project_options(parser)
+    parser.on('-n', '--new [NAME]', String, 'Create new project') do |project|
+      @options[:project] = project
+    end
+
+    parser.on('-a', '--add [MODULES]', Array, 'Integrate modules in project') do |modules|
+      @options[:modules] = parse_modules(modules)
+    end
+
+    parser.on('-l', '--list', 'Show available modules') do
+      list_available_modules
+      @exit_code = 0
+    end
+
+    parser.on('-r', '--verbose', 'Show detailed information') do
+      @sub_options[:verbose] = true
+    end
+
+    parser.on('-v', '--version', 'Show QAT-Cucumber version') do
+      @stdout.puts QAT::Cucumber::VERSION
+      @exit_code = 0
+    end
+
+    parser.on('-h', '--help', 'Show this helper') do
+      @stdout.puts parser.help
+      @exit_code = 0
+    end
+  end
+
+  def parse_modules(modules)
+    modules          = modules.to_a
+    existing_modules = @options[:modules]
+    existing_modules ? existing_modules + modules : modules
+  end
+
+  def list_available_modules
+    modules = QAT::CLI.list_extentions
+
+    @stdout.puts 'List of available modules:'
+    names = modules.map { |module_name| "\t#{module_name}" }
+    @stdout.puts names.join("\n")
+  end
+end

data/lib/qat/cli/plugins/core.rb

@@ -0,0 +1,19 @@
+module QAT
+  module CLI
+    module Plugins
+      #Plugin for CLI functions
+      #@since 0.1.0
+      module Core
+
+        #Function for adding the Core module to a project. Just used for testing, does nothing.
+        #@param stdout [IO] Stdout stream
+        #@param opts [Hash] Options hash
+        #@since 0.1.0
+        def self.add_module stdout, opts
+          stdout.puts 'Nothing to add in Core module' if opts[:verbose]
+        end
+
+      end
+    end
+  end
+end

data/lib/qat/cli.rb

@@ -0,0 +1,52 @@
+require 'little-plugger'
+
+module QAT
+  #Module for CLI functions
+  #@since 0.1.0
+  module CLI
+    #Module as namespace for plugin definition
+    #@since 0.1.0
+    module Plugins
+      #Placeholder
+    end
+    # @!parse extend LittlePlugger
+    send :extend, LittlePlugger( :path => 'qat/cli/plugins', :module => ::QAT::CLI::Plugins )
+
+    #Lists all registered extentions/plugins
+    #@since 0.1.0
+    def self.list_extentions
+      plugins.keys.map(&:to_s).sort
+    end
+
+    #Call add_module in a given plugin.
+    #@param mod [String,Symbol] name of the plugin to call
+    #@param stdout [IO] stdout stream
+    #@param opts [Hash] options hash
+    #@raise ArgumentError When module does not exist
+    #@since 0.1.0
+    def self.add_module mod, stdout, opts
+      raise ArgumentError.new "Module #{mod} is not a plugin!" unless has_module? mod
+
+      loaded_mod = plugins[mod.to_sym]
+
+      if loaded_mod.respond_to? :add_module
+        meth = loaded_mod.method :add_module
+        unless meth.arity == 2 || meth.arity < 0
+          raise ArgumentError.new "Invalid implementation of add_module in #{mod}: should have 2 parameters: stdout, opts"
+        end
+        meth.call stdout, opts
+      else
+        stdout.puts "Nothing to add in #{mod}"
+      end
+    end
+
+
+    #Check if a plugin exists
+    #@param mod [String,Symbol] name of the plugin to call
+    #@return [true,false] true if the plugin exists
+    #@since 0.1.0
+    def self.has_module? mod
+      return plugins.has_key? mod.to_sym
+    end
+  end
+end

data/lib/qat/cucumber/core_ext/formatter/html.rb

@@ -0,0 +1,48 @@
+require 'cucumber/formatter/html'
+
+#Extension to the cucumber module adding the embed video options
+module Cucumber
+  #Extension to the formatter module adding the embed video options
+  module Formatter
+    #Extension to the html class adding the embed video options
+    class Html
+      #Method embed that also contains options to embed video case the extension is met
+      def embed(src, mime_type, label)
+        case (mime_type)
+          when /^image\/(png|gif|jpg|jpeg)/
+            unless File.file?(src) or src =~ /^data:image\/(png|gif|jpg|jpeg);base64,/
+              type = mime_type =~ /;base[0-9]+$/ ? mime_type : mime_type + ";base64"
+              src  = "data:" + type + "," + src
+            end
+            embed_image(src, label)
+          when /^text\/plain/
+            embed_text(src, label)
+          when /^video\/\w+/
+            embed_video(src,mime_type, label)
+        end
+      end
+
+      #Method to embed the video in the HTML Report
+      def embed_video(src,mime_type, label)
+        @video_id ||= 0
+
+        if @io.respond_to?(:path) and File.file?(src)
+          out_dir = Pathname.new(File.dirname(File.absolute_path(@io.path)))
+          src     = Pathname.new(File.absolute_path(src)).relative_path_from(out_dir)
+        end
+
+        @builder.span(:class => 'embed') do |pre|
+          pre << %{
+          <a href="" onclick="video=document.getElementById('video_div_#{@video_id}'); video.style.display = (video.style.display == 'none' ? 'block' : 'none');return false"><br>#{label}</a><br>&nbsp;
+          <div id="video_div_#{@video_id}" style="display: none">
+          <video id="video_#{@video_id}" autostart="0" width="800" height="600" controls> <source src="#{src}"  type="#{mime_type}" ></video><br>
+          <a href="#{src}" download="#{src}">Download Video</a>
+          </div>}
+        end
+
+        @video_id += 1
+      end
+    end
+  end
+end
+

data/lib/qat/cucumber/core_ext/formatter/junit.rb

@@ -0,0 +1,57 @@
+require 'cucumber/formatter/junit'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format junit</tt>
+    class Junit
+
+      #Method to parse time in testsuite elements
+      def end_feature(feature_data)
+        @testsuite = Builder::XmlMarkup.new(:indent => 2)
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          :failures => feature_data[:failures],
+          :errors   => feature_data[:errors],
+          :skipped  => feature_data[:skipped],
+          :tests    => feature_data[:tests],
+          :time     => "%.3f" % feature_data[:time],
+          :name     => feature_data[:feature].name) do
+          @testsuite << feature_data[:builder].target!
+        end
+
+        write_file(feature_result_filename(feature_data[:feature].file), @testsuite.target!)
+      end
+
+      #Method to parse time in testcase elements
+      def build_testcase(result, scenario_designation, output)
+        duration = ResultBuilder.new(result).test_case_duration
+        @current_feature_data[:time] += duration
+        classname = @current_feature_data[:feature].name
+        name = scenario_designation
+
+        @current_feature_data[:builder].testcase(:classname => classname, :name => name, :time => "%.3f" % duration) do
+          if !result.passed? && result.ok?(@config.strict?)
+            @current_feature_data[:builder].skipped
+            @current_feature_data[:skipped] += 1
+          elsif !result.passed?
+            status = result.to_sym
+            exception = get_backtrace_object(result)
+            @current_feature_data[:builder].failure(:message => "#{status} #{name}", :type => status) do
+              @current_feature_data[:builder].cdata! output
+              @current_feature_data[:builder].cdata!(format_exception(exception)) if exception
+            end
+            @current_feature_data[:failures] += 1
+          end
+          @current_feature_data[:builder].tag!('system-out') do
+            @current_feature_data[:builder].cdata! strip_control_chars(@interceptedout.buffer.join)
+          end
+          @current_feature_data[:builder].tag!('system-err') do
+            @current_feature_data[:builder].cdata! strip_control_chars(@interceptederr.buffer.join)
+          end
+        end
+        @current_feature_data[:tests] += 1
+      end
+    end
+  end
+end
+

data/lib/qat/cucumber/core_ext/result.rb

@@ -0,0 +1,16 @@
+require 'cucumber/core/test/result'
+
+#Patch for Cucumber::Core::Test::Result::Unknown to implement methods used by the formatters
+#@since 1.1.0
+class Cucumber::Core::Test::Result::Unknown
+
+  #Dummy function
+  def with_appended_backtrace(_)
+    ''
+  end
+
+  #Dummy function
+  def with_filtered_backtrace(_)
+    ''
+  end
+end

data/lib/qat/cucumber/core_ext.rb

@@ -0,0 +1,3 @@
+require_relative 'core_ext/result'
+require_relative 'core_ext/formatter/html'
+require_relative 'core_ext/formatter/junit'

data/lib/qat/cucumber/hooks/scenario.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+require 'cucumber'
+require 'qat/logger'
+
+module QAT
+  module Cucumber
+    #Methods to execute with Cucumber Hooks and at_exit.
+    #@since 0.1.0
+    module Hooks
+      module Scenario
+        include QAT::Logger
+
+        def scenario_tags(scenario)
+          scenario.tags.map { |tag| tag.name }.compact
+        end
+
+        def define_test_id(scenario)
+          test_id = "#{test_id(scenario)}"
+
+          QAT[:current_test_id]     = test_id
+          QAT[:current_test_run_id] = "#{test_id}_#{QAT[:test_start_timestamp].to_i}"
+          log.info "Scenario has test id: #{QAT[:current_test_id]} and test run id: #{QAT[:current_test_run_id]}"
+        end
+
+        private
+        def test_id(scenario)
+          outline_id = get_outline_id(scenario)
+
+          tags    = scenario_tags(scenario)
+          tag     = tags.select { |tag| tag.match /^\@test\#/ }.first
+          test_id = if tag
+                      tag.gsub '@test#', 'test_'
+                    else
+                      log.warn "Scenario does not have a test id! Using a dummy one..."
+                      'test_0'
+                    end
+
+          "#{test_id}#{outline_id}"
+        end
+
+        def get_outline_id(scenario)
+          if scenario.is_a? ::Cucumber::RunningTestCase::ScenarioOutlineExample
+            test_case        = scenario.instance_exec { @test_case }
+            test_case_source = test_case.source
+
+            tables            = get_example_tables(test_case_source)
+            table_lines       = get_examples_size(tables)
+            table_num         = current_outline_index(tables, test_case_source)
+            previous_outlines = count_previous_outlines(table_lines, table_num)
+            "_#{previous_outlines + test_case_source[3].number}"
+          else
+            nil
+          end
+        end
+
+        def get_example_tables(test_case_source)
+          test_case_source[1].instance_exec { @examples_tables }
+        end
+
+        def get_examples_size(tables)
+          tables.each.map { |table| table.example_rows.size }
+        end
+
+        def current_outline_index(tables, test_case_source)
+          tables.index test_case_source[2]
+        end
+
+        def count_previous_outlines(table_lines, table_num)
+          table_lines[0...table_num].inject(0) { |sum, lines| sum += lines; sum }
+        end
+
+        extend self
+      end
+    end
+  end
+end

data/lib/qat/cucumber/hooks.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+require 'cucumber'
+require 'fileutils'
+require 'tmpdir'
+require 'qat/time'
+require_relative 'version'
+require_relative 'hooks/scenario'
+
+module QAT
+  module Cucumber
+    #Methods to execute with Cucumber Hooks and at_exit.
+    #@since 0.1.0
+    module Hooks
+      include QAT::Logger
+
+      class << self
+        #Hook to be executed before a scenario. It executes the following actions:
+        # * save scenario tags (Saved in {QAT::Core} with the :scenario_tags key)
+        # * save current test start timestamp (Saved in {QAT::Core} with the :test_start_timestamp key)
+        # * create a temporary folder (Saved in {QAT::Core} with the :tmp_folder key)
+        def before(scenario)
+          QAT.reset!
+
+          QAT.store :scenario_tags, Scenario.scenario_tags(scenario)
+          QAT.store :test_start_timestamp, QAT::Time.now
+          QAT.store :tmp_folder, Dir.mktmpdir
+
+          Scenario.define_test_id(scenario)
+        rescue => error
+          log.warn { error }
+        end
+
+        def after_step
+          #TODO
+        rescue => error
+          log.warn { error }
+        end
+
+        #Hook to be executed after a scenario. It executes the following actions:
+        # * delete the temporary folder
+        # * reset the cache
+        def after(_)
+          FileUtils.rm_r QAT[:tmp_folder]
+        rescue => error
+          log.warn { error }
+        end
+
+        def at_exit
+          #TODO
+        rescue => error
+          log.warn { error }
+        end
+      end
+    end
+  end
+end
+
+Before do |scenario|
+  QAT::Cucumber::Hooks.before(scenario)
+end
+
+AfterStep do
+  QAT::Cucumber::Hooks.after_step
+end
+
+After do |scenario|
+  QAT::Cucumber::Hooks.after(scenario)
+end
+
+at_exit do
+  QAT::Cucumber::Hooks.at_exit
+end

data/lib/qat/cucumber/logger.rb

@@ -0,0 +1,49 @@
+module QAT
+  module Cucumber
+    # Helper methods for logger configuration
+    # @since 2.0.2
+    module Logger
+      # Configures Logger with a given configuration
+      # @param configuration [Hash] logger configuration
+      def config_logger(configuration)
+        config = validate_logger_config(configuration)
+
+        load_logger_config(config) if config
+      end
+
+      # Validates that a valid logger configuration exists in the QAT environment variable
+      # @param configuration [Hash] logger configuration
+      def validate_logger_config(configuration)
+        logger_env_config = ENV['QAT_LOGGER_CONFIG']
+
+        if logger_env_config
+          raise InvalidConfiguration.new "Configuration file for logger does not exist: '#{logger_env_config}'" unless File.exists?(logger_env_config.to_s)
+          logger_env_config
+        else
+          validate_logger_yaml_config(configuration)
+        end
+      end
+
+      # Validates that a valid logger configuration exists in a YAML file
+      # @param configuration [Hash] logger configuration
+      def validate_logger_yaml_config(configuration)
+        configuration_directory = configuration.directory
+
+        files = [File.join(configuration_directory, configuration.environment, 'logger.yml'),
+                 File.join(configuration_directory, 'common', 'logger.yml')]
+
+        config = files.select { |file| File.exists?(file) }
+
+        config.first
+      end
+
+      # Loads the logger configuration
+      # @param to_load [Hash] logger configuration to load
+      def load_logger_config(to_load)
+        Log4r::YamlConfigurator.load_yaml_file(to_load)
+
+        log.info { "Loaded logger configuration from file '#{to_load}'" }
+      end
+    end
+  end
+end

data/lib/qat/cucumber/time.rb

@@ -0,0 +1,55 @@
+module QAT
+  module Cucumber
+    # Helper methods for time sync
+    # @since 2.0.2
+    module Time
+      include QAT::Logger
+
+      # Mandatory keys for time sync
+      MANDATORY_KEYS = [:sync]
+
+      # Does the time synchronization between the host running tests and a target host
+      def time_sync
+        time = validate_time_options
+
+        sync_options = time[:sync]
+        log.info { "Syncing with host #{sync_options[:host]}." }
+        target = sync_options.values_at(:host, :method, :opts)
+
+        start_time_sync(target, sync_options)
+
+        set_time_zone(time[:zone])
+      end
+
+      # validates that the necessary options are present
+      def validate_time_options
+        time    = QAT.configuration[:time].deep_symbolize_keys
+        missing = MANDATORY_KEYS - time.keys
+
+        raise InvalidConfiguration.new "Time configuration is not valid! Missing: #{missing.join(', ')}" if missing.any?
+
+        time
+      end
+
+      # Does the time sync with the target host
+      # @param target [Array] host, method of sync, options
+      # @param sync_options [Hash] sync options
+      def start_time_sync(target, sync_options)
+        QAT::Time.synchronize(*target)
+      rescue => exception
+        if sync_options[:kill_if_failed]
+          raise
+        else
+          log.warn { "Synchronization failed but proceeding anyway! [(#{exception.class}) #{exception.message}]" }
+          log.debug exception
+        end
+      end
+
+      # Sets the time zone
+      # @param time_zone [String] time zone
+      def set_time_zone(time_zone)
+        QAT::Time.zone = time_zone if time_zone
+      end
+    end
+  end
+end

data/lib/qat/cucumber/version.rb

@@ -0,0 +1,15 @@
+#encoding: utf-8
+
+#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
+    # Represents QAT's version
+    VERSION = '6.0.0'
+  end
+end