hiptest-publisher-fork 3.2.0

data/lib/hiptest-publisher/string.rb

@@ -0,0 +1,76 @@
+require 'i18n'
+
+require_relative 'utils'
+
+class String
+  def literate
+    I18n.enforce_available_locales = false
+    I18n.transliterate(self)
+  end
+
+  def normalize(keep_dashes=false, keep_spaces=false)
+    literated = self.literate
+    literated.strip!
+
+    if keep_spaces
+      literated.gsub!(/\s+/, ' ')
+      literated.gsub!(/[^a-zA-Z0-9_\- "']/, '')
+    else
+      literated.gsub!(/\s+/, '_')
+      if keep_dashes
+        literated.gsub!(/[^a-zA-Z0-9_\-]/, '')
+      else
+        literated.gsub!(/\W/, '')
+      end
+    end
+    literated
+  end
+
+  def normalize_lower
+    normalized = self.normalize
+    normalized.downcase!
+    normalized
+  end
+
+  def normalize_with_dashes
+    self.normalize(true)
+  end
+
+  def normalize_with_spaces
+    self.normalize(false, true)
+  end
+
+  def underscore
+    # based on:
+    # http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    normalized = self.normalize
+    normalized.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    normalized.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    normalized.tr!("-", "_")
+    normalized.downcase!
+    normalized
+  end
+
+  def camelize
+    normalized = self.normalize.split('_')
+    normalized.map! {|w| w.empty? ? "" : "#{w[0].upcase}#{w[1..-1]}"}
+    normalized.join
+  end
+
+  def camelize_lower
+    camelized = self.camelize
+    if camelized.empty?
+      ""
+    else
+      "#{camelized[0].downcase}#{camelized[1..-1]}"
+    end
+  end
+
+  def camelize_upper
+    self.camelize
+  end
+
+  def clear_extension
+    self.split('.')[0]
+  end
+end

data/lib/hiptest-publisher/utils.rb

@@ -0,0 +1,39 @@
+require 'colorize'
+require 'io/console'
+require 'openssl'
+require 'net/http/post/multipart'
+require 'pathname'
+
+
+def hiptest_publisher_path
+  Gem.loaded_specs['hiptest-publisher'].full_gem_path
+rescue
+  '.'
+end
+
+def hiptest_publisher_version
+  Gem.loaded_specs['hiptest-publisher'].version.to_s
+rescue
+  File.read("#{hiptest_publisher_path}/VERSION").strip if File.exists?("#{hiptest_publisher_path}/VERSION")
+end
+
+def pluralize_word(count, singular, plural=nil)
+  if count == 1
+    singular
+  else
+    "#{singular}s"
+  end
+end
+
+def pluralize(count, singular, plural=nil)
+  word = pluralize_word(count, singular, plural)
+  "#{count} #{word}"
+end
+
+def singularize(name)
+  name.to_s.chomp("s")
+end
+
+def clean_path(path)
+  Pathname.new(path).cleanpath.to_s
+end

data/lib/hiptest-publisher/version_checker.rb

@@ -0,0 +1,41 @@
+require 'hiptest-publisher/formatters/reporter'
+require 'hiptest-publisher/utils'
+
+module Hiptest
+  class VersionChecker
+    attr_reader :reporter
+
+    def self.check_version(reporter: nil)
+      reporter ||= Reporter.new
+
+      VersionChecker.new(reporter).check_version
+    end
+
+    def initialize(reporter)
+      @reporter = reporter
+    end
+
+    def check_version
+      latest = get_latest_version
+      return if latest.nil?
+
+      current = hiptest_publisher_version
+
+      if latest == current
+        puts I18n.t('check_version.up_to_date', current: current)
+      else
+        puts I18n.t('check_version.outdated', current: current, latest: latest)
+      end
+    end
+
+    def get_latest_version
+      reporter.with_status_message I18n.t('check_version.title') do
+        latest_gem = Gem.latest_version_for('hiptest-publisher')
+
+        raise RuntimeError, I18n.t('check_version.error') if latest_gem.nil?
+
+        latest = latest_gem.version
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/xml_parser.rb

@@ -0,0 +1,407 @@
+require 'nokogiri'
+require 'colorize'
+
+require_relative 'nodes'
+require_relative 'utils'
+require_relative 'formatters/reporter'
+
+module Hiptest
+  class XMLParser
+    attr_reader :project
+
+    def initialize(source, reporter = nil)
+      @source = source
+      @xml = Nokogiri::XML(source)
+      @reporter = reporter || NullReporter.new
+    end
+
+    def build_nullliteral(value = nil)
+      Hiptest::Nodes::NullLiteral.new
+    end
+
+    def build_stringliteral(value)
+      if value.is_a? String
+        Hiptest::Nodes::StringLiteral.new(value)
+      else
+        Hiptest::Nodes::StringLiteral.new(value.content)
+      end
+    end
+
+    def build_numericliteral(value)
+      if value.is_a? Numeric
+        Hiptest::Nodes::NumericLiteral.new(value)
+      else
+        Hiptest::Nodes::NumericLiteral.new(value.content)
+      end
+    end
+
+    def build_booleanliteral(value)
+      if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        Hiptest::Nodes::BooleanLiteral.new(value)
+      else
+        Hiptest::Nodes::BooleanLiteral.new(value.content)
+      end
+    end
+
+    def build_var(variable)
+      Hiptest::Nodes::Variable.new(variable.content)
+    end
+
+    def build_symbol(symbol)
+      Hiptest::Nodes::Symbol.new(
+        css_first_content(symbol, '> value'),
+        css_first_content(symbol, '> delimiter')
+      )
+    end
+
+    def build_field(field)
+      Hiptest::Nodes::Field.new(
+        build_node(css_first(field, '> base > *')),
+        css_first_content(field, '> name'))
+    end
+
+    def build_index(index)
+      Hiptest::Nodes::Index.new(
+        build_node(css_first(index, '> base > *')),
+        build_node(css_first(index, '> expression > *')))
+    end
+
+    def build_binary_expression(operation)
+      Hiptest::Nodes::BinaryExpression.new(
+        build_node(css_first(operation, '> left > *')),
+        css_first_content(operation, '> operator'),
+        build_node(css_first(operation, '> right > *')))
+    end
+
+    def build_unary_expression(operation)
+      Hiptest::Nodes::UnaryExpression.new(
+        css_first_content(operation, '> operator'),
+        build_node(css_first(operation, '> expression > *')))
+    end
+
+    def build_operation(operation)
+      if css_first(operation, '> left').nil?
+        build_unary_expression(operation)
+      else
+        build_binary_expression(operation)
+      end
+    end
+
+    def build_parenthesis(parenthesis)
+      Hiptest::Nodes::Parenthesis.new(
+        build_node(css_first(parenthesis)))
+    end
+
+    def build_list(list)
+      Hiptest::Nodes::List.new(build_node_list(list.css('> item > *')))
+    end
+
+    def build_dict(dict)
+      items = dict.element_children.map do |item|
+        Hiptest::Nodes::Property.new(
+          item.name,
+          build_node(css_first(item)))
+      end
+      Hiptest::Nodes::Dict.new(items)
+    end
+
+    def build_template(template)
+      Hiptest::Nodes::Template.new(build_node_list(template.css('> *')))
+    end
+
+    def build_assign(assign)
+      Hiptest::Nodes::Assign.new(
+        build_node(css_first(assign, 'to > *')),
+        build_node(css_first(assign, 'value > *')))
+    end
+
+    def build_call(call)
+      Hiptest::Nodes::Call.new(
+        css_first_content(call, '> actionword'),
+        build_arguments(call),
+        css_first_content(call, '> annotation'))
+    end
+
+    def build_arguments(arguments)
+      build_node_list(arguments.css('> arguments > argument'))
+    end
+
+    def build_argument(argument)
+      value = css_first(argument, '> value')
+      Hiptest::Nodes::Argument.new(
+        css_first_content(argument, 'name'),
+        value ? build_node(value) : nil)
+    end
+
+    def build_if(if_then)
+      Hiptest::Nodes::IfThen.new(
+        build_node(css_first(if_then, '> condition > *')),
+        build_node_list(if_then.css('> then > *')),
+        build_node_list(if_then.css('> else > *')))
+    end
+
+    def build_step(step)
+      first_prop = css_first(step)
+      step_value_node = css_first(first_prop)
+      step_value = step_value_node ? build_node(step_value_node) : first_prop.text
+      Hiptest::Nodes::Step.new(
+        first_prop.name,
+        step_value)
+    end
+
+    def build_while(while_loop)
+      Hiptest::Nodes::While.new(
+        build_node(css_first(while_loop, '> condition > *')),
+        build_node_list(while_loop.css('> body > *')))
+    end
+
+    def build_tag(tag)
+      Hiptest::Nodes::Tag.new(
+        css_first_content(tag, '> key'),
+        css_first_content(tag, '> value'))
+    end
+
+    def build_parameter(parameter)
+      default_value = css_first(parameter, '> default_value')
+
+      Hiptest::Nodes::Parameter.new(
+        css_first_content(parameter, 'name'),
+        default_value ? build_node(default_value) : nil)
+    end
+
+    def build_default_value(node)
+      build_node(css_first(node))
+    end
+
+    def build_value(node)
+      build_node(css_first(node))
+    end
+
+    def build_tags(item)
+      build_node_list(item.css('> tags tag'))
+    end
+
+    def build_parameters(item)
+      build_node_list(item.css('> parameters > parameter'))
+    end
+
+    def build_steps(item)
+      build_node_list(item.css('> steps > *'))
+    end
+
+    def build_actionword(actionword)
+      Hiptest::Nodes::Actionword.new(
+        css_first_content(actionword, '> name'),
+        build_tags(actionword),
+        build_parameters(actionword),
+        build_steps(actionword),
+        css_first_content(actionword, '> uid'),
+        css_first_content(actionword, '> description'))
+    end
+
+    def build_libraryActionword(libraryActionword)
+      Hiptest::Nodes::LibraryActionword.new(
+        css_first_content(libraryActionword, '> name'),
+        build_tags(libraryActionword),
+        build_parameters(libraryActionword),
+        build_steps(libraryActionword),
+        css_first_content(libraryActionword, '> uid'),
+        css_first_content(libraryActionword, '> description'))
+    end
+
+    def build_actionwordSnapshot(actionword)
+      Hiptest::Nodes::Actionword.new(
+        css_first_content(actionword, '> name'),
+        build_tags(actionword),
+        build_parameters(actionword),
+        build_steps(actionword),
+        css_first_content(actionword, '> actionwordUid'),
+        css_first_content(actionword, '> description'))
+    end
+
+    def build_scenario(scenario)
+      Hiptest::Nodes::Scenario.new(
+        css_first_content(scenario, '> name'),
+        css_first_content(scenario, '> description'),
+        build_tags(scenario),
+        build_parameters(scenario),
+        build_steps(scenario),
+        css_first_content(scenario, '> folderUid'),
+        build_node(css_first(scenario, '> datatable'), Hiptest::Nodes::Datatable),
+        css_first_content(scenario, 'order_in_parent').to_i)
+    end
+
+    def build_scenarioSnapshot(scs)
+      scenario = build_scenario(scs)
+      datasets = scenario.each_sub_nodes(Hiptest::Nodes::Dataset).to_a
+
+      scenario.add_tags(scs.css('testSnapshot').flat_map { |test| build_tags(test)}.compact)
+
+      if datasets.empty?
+        scenario.set_uid(css_first_content(scs, 'testSnapshot > uid'))
+      else
+        scenario.set_uid(css_first_content(scs, ' > uid'))
+
+        scs.css('testSnapshot').each do |testSnapshot|
+          test_snapshot_uid = css_first_content(testSnapshot, '> uid')
+          dataset_uid = css_first_content(testSnapshot, '> datasetUid')
+
+          dataset = datasets.find { |ds| ds.children[:uid] == dataset_uid }
+          dataset.set_test_snapshot_uid(test_snapshot_uid) if dataset
+        end
+      end
+      scenario
+    end
+
+    def build_datatable(datatable)
+      Hiptest::Nodes::Datatable.new(build_node_list(datatable.css('> dataset')))
+    end
+
+    def build_dataset(dataset)
+      Hiptest::Nodes::Dataset.new(
+        css_first_content(dataset, '> name'),
+        build_node_list(dataset.css('> arguments argument')),
+        css_first_content(dataset, '> datasetUid'))
+    end
+
+    def build_actionwords(actionwords, actionwords_query = '> actionword')
+      build_node_list(actionwords.css(actionwords_query), Hiptest::Nodes::Actionwords)
+    end
+
+    def build_actionwordSnapshots(actionword_snapshots)
+      build_actionwords(actionword_snapshots, '> actionwordSnapshot')
+    end
+
+    def build_scenarios(scenarios, scenarios_query = '> scenario')
+      build_node_list(scenarios.css(scenarios_query), Hiptest::Nodes::Scenarios)
+    end
+
+    def build_scenarioSnapshots(scenario_snapshots)
+      build_scenarios(scenario_snapshots, '> scenarioSnapshot')
+    end
+
+    def build_tests(tests)
+      build_node_list(tests.css('> test'), Hiptest::Nodes::Tests)
+    end
+
+    def build_test(test)
+      Hiptest::Nodes::Test.new(
+        css_first_content(test, 'name'),
+        css_first_content(test, 'description'),
+        build_tags(test),
+        build_steps(test)
+      )
+    end
+
+    def build_folder(folder)
+      Hiptest::Nodes::Folder.new(
+        css_first_content(folder, 'uid'),
+        css_first_content(folder, 'parentUid'),
+        css_first_content(folder, 'name'),
+        css_first_content(folder, 'description'),
+        build_tags(folder),
+        css_first_content(folder, 'order_in_parent').to_i,
+        build_steps(folder))
+    end
+    alias :build_folderSnapshot :build_folder
+
+    def build_testPlan(test_plan, folders_query = '> folder')
+      tp = Hiptest::Nodes::TestPlan.new(
+        build_node_list(test_plan.css(folders_query)))
+
+      tp.organize_folders
+      return tp
+    end
+
+    def build_actionwordLibraries(libraries)
+      Hiptest::Nodes::Libraries.new(
+        build_node_list(libraries.css('> actionwordLibrary'))
+      )
+    end
+
+    def build_actionwordLibrarySnapshots(libraries)
+      Hiptest::Nodes::Libraries.new(
+        build_node_list(libraries.css('> actionwordLibrarySnapshot'))
+      )
+    end
+
+    def build_actionwordLibrary(library)
+      Hiptest::Nodes::Library.new(
+        css_first_content(library, '> name'),
+        build_node_list(library.css('> libraryActionwords libraryActionword'))
+      )
+    end
+
+    def build_actionwordLibrarySnapshot(library)
+      Hiptest::Nodes::Library.new(
+        css_first_content(library, '> name'),
+        build_node_list(library.css('> libraryActionwordSnapshots actionwordSnapshot'))
+      )
+    end
+
+    def build_folderSnapshots(folder_snapshots)
+      build_testPlan(folder_snapshots, '> folderSnapshot')
+    end
+
+    def build_project
+      project = css_first(@xml, 'project')
+      test_run = css_first(project, '> testRuns > testRun')
+
+      if test_run.nil?
+        test_plan_node = css_first(project, '> testPlan')
+        scenarios_node = css_first(project, '> scenarios')
+        actionwords_node = css_first(project, '> actionwords')
+        libraries_node = css_first(project, '> actionwordLibraries')
+      else
+        test_plan_node = css_first(test_run, '> folderSnapshots')
+        scenarios_node = css_first(test_run, '> scenarioSnapshots')
+        actionwords_node = css_first(test_run, '> actionwordSnapshots')
+        libraries_node = css_first(test_run, '> actionwordLibrarySnapshots')
+      end
+
+      @project = Hiptest::Nodes::Project.new(
+        css_first_content(project, '> name'),
+        css_first_content(project, '> description'),
+        build_node(test_plan_node, Hiptest::Nodes::TestPlan),
+        build_node(scenarios_node, Hiptest::Nodes::Scenarios),
+        build_node(actionwords_node, Hiptest::Nodes::Actionwords),
+        build_node(css_first(project, '> tests'), Hiptest::Nodes::Tests),
+        build_node(libraries_node, Hiptest::Nodes::Libraries)
+      )
+
+      @project.assign_scenarios_to_folders
+      return @project
+    end
+
+    private
+
+    def build_node(node, default_node=nil)
+      if node.nil? && default_node
+        return default_node.new
+      end
+      self.send("build_#{node.name}", node)
+    rescue => error
+      @reporter.dump_error(error, I18n.t('build_data.error', node: node.to_s))
+      nil
+    end
+
+    def build_node_list(l, container_class=nil)
+      items = l.map {|item| build_node(item)}
+
+      unless container_class.nil?
+        container_class.new(items)
+      else
+        items
+      end
+    end
+
+    def css_first(node, selector = '> *')
+      node.css(selector).first
+    end
+
+    def css_first_content(node, selector = '> *')
+      sub_node = css_first(node, selector)
+      sub_node.nil? ? nil : sub_node.content
+    end
+  end
+end