hiptest-publisher-fork 3.2.0

data/lib/hiptest-publisher/cli_options_checker.rb

@@ -0,0 +1,270 @@
+require 'i18n'
+require 'pathname'
+
+require 'hiptest-publisher/utils'
+
+module Hiptest
+  class CliOptionError < StandardError
+  end
+
+  class CliOptionsChecker
+    attr_reader :reporter, :cli_options
+    def initialize(cli_options, reporter)
+      @cli_options = cli_options
+      @reporter = reporter
+    end
+
+    def check!
+      check_config_file
+
+      if cli_options.only == 'list'
+        return
+      end
+
+      check_secret_token
+      check_filters
+      check_status_filter
+      check_meta
+
+      if cli_options.push?
+        check_execution_environment
+        check_push_file
+        check_build_options
+      else
+        check_output_directory
+        check_actionwords_signature_file
+        check_xml_file
+        check_test_run_id
+        check_language_and_only
+      end
+    end
+
+    def check_config_file
+      begin
+        ParseConfig.new(cli_options.config) if present?(cli_options.config)
+      rescue Errno::EACCES => err
+        raise CliOptionError, I18n.t('errors.cli_options.missing_config_file', config_file: cli_options.config)
+      end
+    end
+
+    def check_filters
+      filters = [
+        cli_options.filter_on_scenario_ids,
+        cli_options.filter_on_folder_ids,
+        cli_options.filter_on_scenario_name,
+        cli_options.filter_on_folder_name,
+        cli_options.filter_on_tags
+      ].reject {|opt| absent?(opt) }
+
+      return if filters.empty?
+
+      if filters.size > 1
+        raise CliOptionError, I18n.t('errors.cli_options.multiple_filters')
+      end
+
+      if present?(cli_options.test_run_id) || present?(cli_options.test_run_name)
+        raise CliOptionError, I18n.t('errors.cli_options.filter_with_test_run')
+      end
+
+      check_numeric_list(:filter_on_scenario_ids)
+      check_numeric_list(:filter_on_folder_ids)
+      check_tag_list(:filter_on_tags)
+    end
+
+    def check_status_filter
+      return if absent?(cli_options.filter_on_status)
+
+      if absent?(cli_options.test_run_id) && absent?(cli_options.test_run_name)
+          raise CliOptionError, I18n.t('errors.cli_options.filter_status_without_test_run')
+      end
+    end
+
+    def check_secret_token
+      if absent?(cli_options.xml_file)
+        if absent?(cli_options.token)
+          raise CliOptionError, I18n.t('errors.cli_options.missing_token')
+        end
+
+        unless numeric?(cli_options.token)
+          raise CliOptionError, I18n.t('errors.cli_options.invalid_token', token: cli_options.token)
+        end
+      end
+    end
+
+    def check_push_file
+      if cli_options.push && !cli_options.global_failure_on_missing_reports
+        agnostic_path = clean_path(cli_options.push)
+        globbed_files = Dir.glob(agnostic_path)
+
+        if globbed_files.length == 0
+          raise CliOptionError, I18n.t('errors.cli_options.unreadable_report_file', path: cli_options.push)
+        elsif globbed_files.length == 1 && globbed_files == [cli_options.push]
+          if !File.readable?(agnostic_path)
+            raise CliOptionError, I18n.t('errors.cli_options.unreadable_report_file', path: cli_options.push)
+          elsif !File.file?(agnostic_path)
+            raise CliOptionError, I18n.t('errors.cli_options.irregular_report_file', path: cli_options.push)
+          end
+        end
+      end
+    end
+
+    def check_execution_environment
+      if cli_options.execution_environment
+        if cli_options.execution_environment.length > 255
+          raise CliOptionError, I18n.t('errors.cli_options.invalid_execution_environment')
+        end
+      end
+    end
+
+    def check_output_directory
+      output_directory = clean_path(cli_options.output_directory)
+
+      parent = first_existing_parent(output_directory)
+      if !parent.writable?
+        if parent.realpath === Pathname.new(cli_options.output_directory).cleanpath
+          raise CliOptionError, I18n.t('errors.cli_options.output_directory_not_writable', output_dir: cli_options.output_directory)
+        else
+          raise CliOptionError, I18n.t('errors.cli_options.output_directory_parent_not_writable', realpath: parent.realpath, output_dir: cli_options.output_directory)
+        end
+      elsif !parent.directory?
+        raise CliOptionError, I18n.t('errors.cli_options.output_directory_not_directory', output_dir: cli_options.output_directory)
+      end
+    end
+
+
+    def check_actionwords_signature_file
+      if cli_options.actionwords_diff?
+        actionwords_signature_file = Pathname.new(cli_options.output_directory).join("actionwords_signature.yaml")
+        if actionwords_signature_file.directory?
+          raise CliOptionError, I18n.t('errors.cli_options.actionwords_signature_directory', path: actionwords_signature_file.realpath)
+        elsif !actionwords_signature_file.exist?
+          raise CliOptionError, I18n.t('errors.cli_options.missing_actionwords_signature_file', directory_path: File.expand_path(cli_options.output_directory))
+        end
+      end
+    end
+
+    def check_xml_file
+      if cli_options.xml_file
+        xml_path = clean_path(cli_options.xml_file)
+
+        if !File.readable?(xml_path)
+          raise CliOptionError, I18n.t('errors.cli_options.unreadable_xml_file', path: cli_options.xml_file)
+        elsif !File.file?(xml_path)
+          raise CliOptionError, I18n.t('errors.cli_options.irregular_xml_file', path: cli_options.xml_file)
+        end
+      end
+    end
+
+    def check_test_run_id
+      if present?(cli_options.test_run_id) && !numeric?(cli_options.test_run_id)
+        raise CliOptionError, I18n.t('errors.cli_options.invalid_test_run_id', test_run_id: cli_options.test_run_id)
+      end
+    end
+
+    def check_numeric_list(option_name)
+      value = cli_options.send(option_name)
+      return if absent?(value)
+
+       value.split(',').each do |val|
+        next if numeric?(val.strip)
+        raise CliOptionError, I18n.t('errors.cli_options.invalid_numeric_value_list', option: option_name, incorrect_value: val.strip.inspect)
+       end
+    end
+
+    def check_tag_list(option_name)
+      value = cli_options.send(option_name)
+      return if absent?(value)
+
+      value.split(',').each do |val|
+        next if tag_compatible?(val.strip)
+        raise CliOptionError, I18n.t('errors.cli_options.invalid_tag_value_list', option: option_name, incorrect_value: val.strip.inspect)
+      end
+    end
+
+    def check_meta
+      value = cli_options.meta
+      return if absent?(value)
+
+      value.split(',').each do |val|
+        next if meta_compatible?(val.strip)
+        raise CliOptionError, I18n.t('errors.cli_options.invalid_meta', incorrect_value: val.strip.inspect)
+      end
+    end
+
+    def check_language_and_only
+      if present?(cli_options.language)
+        begin
+          language_config_parser = LanguageConfigParser.new(cli_options)
+        rescue ArgumentError => err
+          raise CliOptionError, err.message
+        end
+
+        if present?(cli_options.only)
+          if language_config_parser.filtered_group_names != cli_options.groups_to_keep
+            unknown_categories = cli_options.groups_to_keep - language_config_parser.group_names
+            raise CliOptionError, I18n.t(
+              'errors.cli_options.invalid_category',
+              count: unknown_categories.length,
+              invalid_categories: formatted_categories(unknown_categories),
+              available_categories: formatted_categories(language_config_parser.group_names),
+              language: cli_options.language_framework
+            )
+          end
+        end
+      end
+    end
+
+    def check_build_options
+      if present?(cli_options.build_id) && present?(cli_options.build_name)
+        raise CliOptionError, I18n.t('errors.cli_options.multiple_build_options')
+      end
+    end
+
+    private
+
+    def numeric?(arg)
+      arg =~ /\A\d*\z/
+    end
+
+    def missing?(arg)
+      arg.nil?
+    end
+
+    def empty?(arg)
+      arg.strip.empty?
+    end
+
+    def absent?(arg)
+      missing?(arg) || empty?(arg)
+    end
+
+    def present?(arg)
+      !absent?(arg)
+    end
+
+    def tag_compatible?(value)
+      value =~ /\A[a-zA-Z0-9_-]*(: ?[a-zA-Z0-9_-]*)?\z/
+    end
+
+    def meta_compatible?(value)
+      value =~ /\A[a-zA-Z0-9_-]*: ?.*\z/
+    end
+
+    def formatted_categories(categories)
+      formatted_categories = categories.map(&:inspect)
+      if formatted_categories.length == 1
+        formatted_categories.first
+      else
+        I18n.t(:readable_list, first_items: formatted_categories[0...-1].join(", "), last_item: formatted_categories.last)
+      end
+    end
+
+    def first_existing_parent(path)
+      pathname = Pathname.new(path)
+      while !pathname.exist?
+        pathname = pathname.parent
+      end
+      pathname.realpath
+    end
+  end
+end

data/lib/hiptest-publisher/client.rb

@@ -0,0 +1,326 @@
+require 'erb'
+require 'i18n'
+require 'json'
+require 'net/http'
+require 'uri'
+
+require_relative 'export_cache'
+require_relative 'formatters/reporter'
+
+module Hiptest
+
+  class ClientError < StandardError
+  end
+
+  class RedirectionError < StandardError
+    attr_reader :redirect
+
+    def initialize(msg, redirect)
+      @redirect = redirect
+      super(msg)
+    end
+  end
+
+  class AsyncExportUnavailable < StandardError
+  end
+
+  class MaximumRedirectionReachedError < StandardError
+  end
+
+  MAX_REDIRECTION = 10
+
+  class Client
+    attr_reader :cli_options
+    attr_writer :async_options
+
+    def initialize(cli_options, reporter = nil)
+      @cli_options = cli_options
+      @reporter = reporter || NullReporter.new
+      @async_options = { max_attempts: 200, sleep_time_between_attemps: 5 }
+    end
+
+    def url
+      if cli_options.push?
+        "#{cli_options.site}/import_test_results/#{cli_options.token}/#{cli_options.push_format}#{push_query_parameters}"
+      elsif test_run_id
+        "#{base_publication_path}/test_run/#{test_run_id}#{test_run_export_filter}"
+      else
+        "#{base_publication_path}/#{cli_options.leafless_export ? 'leafless_tests' : 'project'}#{project_export_filters}"
+      end
+    end
+
+    def global_failure_url
+      "#{cli_options.site}/report_global_failure/#{cli_options.token}/#{cli_options.test_run_id}/"
+    end
+
+    def project_export_filters
+      mapping = {
+        filter_on_scenario_ids: 'filter_scenario_ids',
+        filter_on_folder_ids: 'filter_folder_ids',
+        filter_on_scenario_name: 'filter_scenario_name',
+        filter_on_folder_name: 'filter_folder_name',
+        filter_on_tags: 'filter_tags'
+      }
+
+      options = []
+
+      mapping.each do |key, filter_name|
+        value = @cli_options[key]
+        next if value.nil? || value.empty?
+
+        if [:filter_on_scenario_ids, :filter_on_folder_ids, :filter_on_tags].include?(key)
+          value = value.split(',').map(&:strip).map{ |s| ERB::Util.url_encode(s) }.join(',')
+        else
+          value = ERB::Util.url_encode(value)
+        end
+
+        options << "#{filter_name}=#{value}"
+        if [:filter_on_folder_ids, :filter_on_folder_name].include?(key) && @cli_options[:not_recursive]
+          options << "not_recursive=true"
+        end
+      end
+
+
+      return options.empty? ? '' : "?#{options.join('&')}"
+    end
+
+    def test_run_export_filter
+      value = @cli_options.filter_on_status
+      return '' if value.nil? || value.empty?
+
+      return "?filter_status=#{value}"
+    end
+
+    def fetch_project
+      cached = export_cache.cache_for(url)
+
+      unless cached.nil?
+        @reporter.with_status_message I18n.t(:using_cached_data) do
+          return cached
+        end
+      end
+
+      content = @reporter.with_status_message I18n.t(:fetching_data) do
+        break fetch_project_export if use_synchronous_fetch?
+
+        begin
+          fetch_project_export_asynchronously
+        rescue AsyncExportUnavailable
+          fetch_project_export
+        end
+      end
+
+      export_cache.cache(url, content)
+      content
+    end
+
+    def available_test_runs
+      @available_test_runs ||= begin
+        response = send_get_request("#{base_publication_path}/test_runs")
+        if response.code_type == Net::HTTPNotFound
+          :api_not_available
+        else
+          json_response = JSON.parse(response.body)
+          json_response["test_runs"]
+        end
+      end
+    end
+
+    def push_results
+      # Code from: https://github.com/nicksieger/multipart-post
+      uploaded = {}
+      Dir.glob(cli_options.push.gsub('\\', '/')).each do |filename|
+        uploaded["file-#{filename.normalize}"] = filename
+      end
+
+      if cli_options.global_failure_on_missing_reports && uploaded.empty?
+        return send_post_request(global_failure_url)
+      end
+
+      send_multipart_request(url, uploaded)
+    end
+
+    private
+
+    def use_synchronous_fetch?
+      cli_options.push? || cli_options.leafless_export || test_run_id
+    end
+
+    def fetch_project_export
+      response = send_get_request(url)
+      if response.code_type == Net::HTTPNotFound
+        raise ClientError, I18n.t('errors.project_not_found')
+      end
+
+      response.body
+    end
+
+    def fetch_project_export_asynchronously
+      publication_export_id = fetch_asynchronous_publication_export_id
+      url = "#{base_publication_path}/async_project/#{publication_export_id}"
+      response = nil
+
+      # the server should respond with a timeout after 15 minutes
+      # it is about 180 attempts with a sleep time of 5 seconds between each requests
+      sleep_time_between_attemps = @async_options[:sleep_time_between_attemps]
+      max_attempts = @async_options[:max_attempts]
+
+      loop do
+        response = send_get_request(url)
+
+        break unless response.code_type == Net::HTTPAccepted
+        break if 0 >= (max_attempts -= 1)
+
+        sleep(sleep_time_between_attemps)
+      end
+
+      response.body
+    end
+
+    def fetch_asynchronous_publication_export_id
+      url = "#{base_publication_path}/async_project#{project_export_filters}"
+      response = send_post_request(url)
+
+      raise AsyncExportUnavailable if response.code_type == Net::HTTPNotFound
+
+      JSON.parse(response.body)['publication_export_id']
+    end
+
+    def export_cache
+      @export_cache ||= ExportCache.new(
+        @cli_options.cache_dir,
+        @cli_options.cache_duration,
+        reporter: @reporter)
+    end
+
+    def test_run_id
+      return unless cli_options.test_run_id? || cli_options.test_run_name?
+
+      if cli_options.test_run_id?
+        key = "id"
+        searched_value = cli_options.test_run_id
+      elsif cli_options.test_run_name?
+        key = "name"
+        searched_value = cli_options.test_run_name
+      end
+
+      if available_test_runs == :api_not_available
+        if cli_options.test_run_id?
+          cli_options.test_run_id
+        else
+          raise ClientError, I18n.t('errors.test_run_list_unavailable')
+        end
+      else
+        matching_test_run = available_test_runs.find { |test_run| test_run[key] == searched_value }
+        if matching_test_run.nil?
+          raise ClientError, no_matching_test_runs_error_message
+        end
+        matching_test_run["id"]
+      end
+    end
+
+    def no_matching_test_runs_error_message
+      if available_test_runs.empty?
+        I18n.t('errors.no_test_runs')
+      else
+        I18n.t('errors.no_matching_test_run', test_runs: columnize_test_runs(available_test_runs))
+      end
+    end
+
+    def columnize_test_runs(test_runs)
+      lines = []
+      lines << ["ID", "Name"]
+      lines << ["--", "----"]
+      lines += test_runs.map { |tr| [tr["id"], tr["name"]] }
+      first_column_width = lines.map { |line| line[0].length }.max
+      lines.map! { |line| "  #{line[0].ljust(first_column_width)}  #{line[1]}" }
+      lines.join("\n")
+    end
+
+    def base_publication_path
+      "#{cli_options.site}/publication/#{cli_options.token}"
+    end
+
+    def send_get_request(url, attempt = MAX_REDIRECTION)
+      raise MaximumRedirectionReachedError if attempt < 0
+
+      uri = URI.parse(url)
+      send_request(Net::HTTP::Get.new(uri))
+    rescue RedirectionError => err
+      send_get_request(err.redirect, attempt - 1)
+    end
+
+    def send_post_request(url, attempt = MAX_REDIRECTION)
+      raise MaximumRedirectionReachedError if attempt < 0
+
+      uri = URI.parse(url)
+      send_request(Net::HTTP::Post.new(uri))
+    rescue RedirectionError => err
+      send_post_request(err.redirect, attempt - 1)
+    end
+
+    def send_multipart_request(url, uploaded, attempt = MAX_REDIRECTION)
+      raise MaximumRedirectionReachedError if attempt < 0
+
+      uri = URI.parse(url)
+      files = {}
+      uploaded.each do |fieldname, filename|
+        files[fieldname] = UploadIO.new(File.new(filename), "text", filename)
+      end
+
+      send_request(Net::HTTP::Post::Multipart.new(uri, files))
+    rescue RedirectionError => err
+      send_multipart_request(err.redirect, uploaded, attempt - 1)
+    end
+
+    def send_request(request)
+      request["User-Agent"] = "Ruby/hiptest-publisher"
+      use_ssl = request.uri.scheme == "https"
+
+      proxy_uri = find_proxy_uri(request.uri.hostname, request.uri.port)
+      if proxy_uri
+        proxy_address = proxy_uri.hostname
+        proxy_port = proxy_uri.port
+        proxy_user, proxy_pass = proxy_uri.userinfo.split(':', 2) if proxy_uri.userinfo
+      end
+
+      Net::HTTP.start(
+          request.uri.hostname, request.uri.port,
+          proxy_address, proxy_port, proxy_user, proxy_pass,
+          use_ssl: use_ssl,
+          verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+        @reporter.show_verbose_message(I18n.t(:request_sent, uri: request.uri))
+        response = http.request(request)
+
+        raise RedirectionError.new("Got redirected", response['location']) if response.is_a?(Net::HTTPRedirection)
+
+        response
+      end
+    end
+
+    def find_proxy_uri(address, port)
+      return URI.parse(@cli_options.http_proxy) if @cli_options.http_proxy
+
+      URI::HTTP.new(
+        "http", nil, address, port, nil, nil, nil, nil, nil
+      ).find_proxy
+    end
+
+    def push_query_parameters
+      parameters = {}
+      unless cli_options.execution_environment.strip.empty?
+        parameters['execution_environment'] = cli_options.execution_environment
+      end
+
+      unless cli_options.build_id.strip.empty?
+        parameters['build_id'] = cli_options.build_id
+      end
+
+      unless cli_options.build_name.strip.empty?
+        parameters['build_name'] = cli_options.build_name
+      end
+
+      parameters.empty? ? "" : "?#{parameters.map {|key, value| "#{key}=#{ERB::Util.url_encode(value)}"}.join("&")}"
+    end
+  end
+end

data/lib/hiptest-publisher/export_cache.rb

@@ -0,0 +1,85 @@
+require 'i18n'
+
+require_relative 'formatters/reporter'
+require_relative 'file_writer'
+
+
+module Hiptest
+  class ExportCache
+    def initialize(cache_dir, cache_duration, reporter: nil)
+      @cache_dir = cache_dir
+      @cache_duration = cache_duration
+      @reporter = reporter || Reporter.new
+
+      clear_cache
+    end
+
+    def cache(url, content, date: nil)
+      return if @cache_duration <= 0
+
+      date ||= Time.now
+      filename = "#{Digest::MD5.hexdigest(url)}-#{date.to_i}"
+
+      file_writer.write_to_file(File.join(@cache_dir, filename), I18n.t("caching_data")) { content }
+    end
+
+    def cache_for(url)
+      return if @cache_duration <= 0
+
+      hashed_url = Digest::MD5.hexdigest(url)
+      expiry_date = (Time.now - @cache_duration).to_i
+
+      cached_filename = cached_filenames
+        .select do |filename |
+          filename.start_with?("#{hashed_url}-") && !expired?(filename, expiry_date)
+        end
+        .sort do | f1, f2|
+          timestamp_from_filename(f1) <=> timestamp_from_filename(f2)
+        end
+        .last
+
+      return nil if cached_filename.nil?
+
+      full_path = File.join(@cache_dir, cached_filename)
+      @reporter.show_verbose_message(I18n.t(:using_cache, full_path: full_path))
+      File.read(full_path)
+    end
+
+    def clear_cache
+      expired_files.map do |filename|
+        FileUtils.rm(File.join(@cache_dir, filename))
+      end
+    end
+
+    private
+
+    def file_writer
+      FileWriter.new(@reporter)
+    end
+
+    def expired_files
+      expiry_date = (Time.now - @cache_duration).to_i
+
+      cached_filenames.select do |filename |
+        expired?(filename, expiry_date)
+      end
+    end
+
+    def cached_filenames
+      Dir
+        .entries(@cache_dir)
+        .select { |entry| File.file?(File.join(@cache_dir, entry)) }
+      rescue Errno::ENOENT => err
+        []
+    end
+
+    def expired?(filename, expiry_date)
+      timestamp_from_filename(filename) < expiry_date
+    end
+
+    def timestamp_from_filename(filename)
+      m = filename.match(/\A[a-f0-9]{32}-(\d+)\Z/)
+      m.nil? ? nil : m[1].to_i
+    end
+  end
+end

data/lib/hiptest-publisher/file_writer.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+
+module Hiptest
+  class FileWriter
+    def initialize(reporter)
+      @reporter = reporter
+    end
+
+    def write_to_file(path, message)
+      @reporter.with_status_message "#{message}: #{path}" do
+        mkdirs_for(path)
+        content = yield
+
+        File.open(path, 'w') do |file|
+          file.write(content)
+        end
+      end
+    rescue => err
+      @reporter.dump_error(err)
+    end
+
+    private
+
+    def mkdirs_for(path)
+      unless Dir.exists?(File.dirname(path))
+        FileUtils.mkpath(File.dirname(path))
+      end
+    end
+  end
+end