hiptest-publisher-fork 3.2.0

data/lib/hiptest-publisher/project_grapher.rb

@@ -0,0 +1,94 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  # Builds a graph based on calls and computes
+  # longest path from the root.
+
+  class ProjectGrapher
+    attr_reader :graph, :distance_index
+
+    def self.distances_index(project)
+      instance = ProjectGrapher.new(project)
+      instance.compute_graph
+      instance.add_distances
+      instance.index_by_distances
+
+      return instance.distance_index
+    end
+
+    def initialize(project)
+      @project = project
+      @graph = {}
+    end
+
+    def compute_graph
+      add_nodes
+      add_root
+    end
+
+    def add_distances
+      add_node_weight(@graph[:root], [:root])
+    end
+
+    def index_by_distances
+      @distance_index = Hash.new { |hash, key| hash[key] = [] }
+      @graph.each_value do |value|
+        @distance_index[value[:distance_from_root]] << value[:item] if value[:item]
+      end
+    end
+
+    private
+
+    def add_nodes
+      @project.each_sub_nodes(Hiptest::Nodes::Scenario, Hiptest::Nodes::Actionword) do |item|
+        name = node_name(item)
+        @graph[name] = {
+          name: name,
+          item: item,
+          calls: [],
+          distance_from_root: -1
+        }
+
+        item.each_sub_nodes(Hiptest::Nodes::Call) do |call|
+          aw_name = node_name(call.children[:actionword], Hiptest::Nodes::Actionword)
+          @graph[name][:calls] << aw_name
+        end
+      end
+    end
+
+    def add_root
+      @graph[:root] = {
+        calls: [],
+        distance_from_root: 0
+      }
+
+      @project.each_sub_nodes(Hiptest::Nodes::Scenario) do |scenario|
+        @graph[:root][:calls] << node_name(scenario)
+      end
+    end
+
+    def add_node_weight(node, path)
+      path << node[:name]
+
+      node[:calls].each do |item_name|
+        next if path.include?(item_name)
+
+        called = @graph[item_name]
+        next if called.nil?
+
+        if called[:distance_from_root] <= node[:distance_from_root]
+          called[:distance_from_root] = node[:distance_from_root] + 1
+          add_node_weight(called, path)
+        end
+      end
+
+      path.pop
+    end
+
+    def node_name(node, cls = nil)
+      cls ||= node.class
+      name = node.is_a?(Hiptest::Nodes::Node) ? node.children[:name] : node
+      "#{cls}-#{name}"
+    end
+  end
+end

data/lib/hiptest-publisher/render_context_maker.rb

@@ -0,0 +1,194 @@
+module Hiptest
+  module RenderContextMaker
+    def walk_item(item)
+      {
+        has_description?: !item.children[:description].nil? && !item.children[:description].empty?,
+        has_parameters?: !item.children[:parameters].empty?,
+        has_tags?: !item.children[:tags].empty?,
+        has_step?: has_step?(item),
+        is_empty?: item.children[:body].empty?,
+        declared_variables: item.declared_variables_names,
+        raw_parameter_names: item.children[:parameters].map {|p| p.children[:name] },
+        self_name: item.children[:name]
+      }
+    end
+
+    def walk_relative_item(item)
+      relative_package = @context.relative_path.split('/')[0...-1].join('.')
+      relative_package = ".#{relative_package}" unless relative_package.empty?
+      {
+        needs_to_import_actionwords?: @context.relative_path.count('/') > 0,
+        relative_package: relative_package,
+      }
+    end
+
+    def walk_actionword(aw)
+      walk_item(aw).merge(
+        chunks: aw.chunks || [],
+        extra_inlined_parameters: aw.extra_inlined_parameters || [],
+        has_free_text_parameter?: aw.children[:parameters].select(&:free_text?).count > 0,
+        has_datatable_parameter?: aw.children[:parameters].select(&:datatable?).count > 0,
+        uniq_name: aw.uniq_name
+      )
+    end
+
+    def walk_actionwords(aws)
+      project = aws.parent
+      {
+        uses_library?: project.nil? ? false : project.has_libraries?
+      }
+    end
+
+    def walk_folder(folder)
+      walk_relative_item(folder).merge(
+        self_name: folder.children[:name],
+        has_tags?: !folder.children[:tags].empty?,
+        has_step?: has_step?(folder),
+        is_empty?: folder.children[:body].empty?,
+        datatables_present?: datatable_present?(folder)
+      )
+    end
+
+    def walk_scenario(scenario)
+      walk_item(scenario).merge(walk_relative_item(scenario)).merge(
+        project_name: scenario.parent.parent.children[:name],
+        has_datasets?: has_datasets?(scenario),
+        has_annotations?: has_annotations?(scenario),
+        uniq_name: scenario.children[:name]
+      )
+    end
+
+    def walk_dataset(dataset)
+      datatable = dataset.parent
+      {
+        scenario_name: datatable.parent.children[:name],
+        has_tags?: !datatable.parent.children[:tags].empty?,
+        tags: datatable.parent.children[:tags].map {|tag| @rendered[tag]}
+      }
+    end
+
+    def walk_scenarios(scenarios)
+      project = scenarios.parent
+      {
+        project_name: project.children[:name],
+        self_name: project.children[:name],
+        datatables_present?: datatable_present?(scenarios)
+      }
+    end
+
+    def walk_test(test)
+      {
+        has_description?: !test.children[:description].nil? && !test.children[:description].empty?,
+        has_parameters?: false,
+        has_tags?: !test.children[:tags].empty?,
+        has_step?: has_step?(test),
+        is_empty?: test.children[:body].empty?,
+        has_datasets?: false,
+        project_name: test.parent.parent.children[:name],
+        self_name: test.children[:name]
+      }
+    end
+
+    def walk_tests(tests)
+      project = tests.parent
+      {
+        project_name: project.children[:name],
+        self_name: project.children[:name]
+      }
+    end
+
+    def walk_call(c)
+      {
+        has_arguments?: !c.children[:arguments].empty?,
+        has_annotation?: !c.children[:annotation].nil?,
+        is_shared?: !c.children[:library_name].nil?,
+        in_actionword?: c.parent.is_a?(Hiptest::Nodes::Actionword),
+        in_datatabled_scenario?: c.parent.is_a?(Hiptest::Nodes::Scenario) && has_datasets?(c.parent),
+        chunks: c.chunks || [],
+        extra_inlined_arguments: c.extra_inlined_arguments || []
+      }
+    end
+
+    def walk_ifthen(it)
+      {
+        has_else?: !it.children[:else].empty?
+      }
+    end
+
+    def walk_parameter(p)
+      {
+        is_free_text?: p.free_text?,
+        is_datatable?: p.datatable?,
+        is_bool?: p.children[:type] == :bool,
+        has_default_value?: !p.children[:default].nil?
+      }
+    end
+
+    def walk_tag(t)
+      {
+        has_value?: !t.children[:value].nil?
+      }
+    end
+
+    def walk_template(t)
+      treated = t.children[:chunks].map do |chunk|
+        {
+          is_variable?: chunk.is_a?(Hiptest::Nodes::Variable),
+          raw: chunk
+        }
+      end
+      variable_names = treated.map {|item| item[:raw].children[:name] if item[:is_variable?]}.compact
+
+      {
+        treated_chunks: treated,
+        variable_names: variable_names
+      }
+    end
+
+    def walk_libraryactionword(aw)
+      walk_actionword(aw).merge(
+        library_name: aw.parent.children[:name]
+      )
+    end
+
+    def walk_libraries(libraries)
+      {
+        library_names: libraries.children[:libraries].map {|lib| lib.children[:name]}
+      }
+    end
+
+    private
+
+    def has_step?(item)
+      item.each_sub_nodes(deep: true) do |node|
+        return true if node.is_a?(Hiptest::Nodes::Step)
+      end
+      false
+    end
+
+    def has_annotations?(scenario)
+      scenario.each_sub_nodes(deep: true) do |node|
+        return true if node.is_a?(Hiptest::Nodes::Call) && !node.children[:annotation].nil?
+      end
+      false
+    end
+
+    def has_datasets?(scenario)
+      datatable = scenario.children[:datatable]
+      datatable ? !datatable.children[:datasets].empty? : false
+    end
+
+    def datatable_present?(container)
+      datatables_present = false
+
+      container.children[:scenarios].each do |scenario|
+        if has_datasets?(scenario)
+          datatables_present = true
+          break
+        end
+      end
+
+      return datatables_present
+    end
+  end
+end

data/lib/hiptest-publisher/renderer.rb

@@ -0,0 +1,52 @@
+require 'ruby-handlebars'
+
+require 'hiptest-publisher/nodes_walker'
+require 'hiptest-publisher/render_context_maker'
+
+module Hiptest
+  class Renderer < Hiptest::Nodes::Walker
+    attr_reader :rendered
+    include RenderContextMaker
+
+    def self.render(node, context)
+      renderer = self.new(context)
+      context.renderer_addons.each do |addon|
+        renderer.singleton_class.include(addon)
+      end
+      renderer.walk_node(node)
+      renderer.rendered[node]
+    end
+
+    def initialize(context)
+      @rendered = {}
+      @context = context
+      @template_finder = context.template_finder
+    end
+
+    def call_node_walker(node)
+      if node.is_a? Hiptest::Nodes::Node
+        @rendered_children = {}
+
+        node.children.each do |name, child| 
+          @rendered_children[name] = @rendered[child]
+
+          @rendered_children[name].uniq! if name == :actionwords && @rendered_children[name].is_a?(Array)
+        end
+        @rendered[node] = render_node(node, super(node))
+      elsif node.is_a? Array
+        @rendered[node] = node.map {|item| @rendered[item]}
+      else
+        @rendered[node] = node
+      end
+    end
+
+    def render_node(node, render_context)
+      render_context ||= {}
+      render_context[:node] = node
+      render_context[:rendered_children] = @rendered_children
+      render_context[:context] = @context
+
+      @template_finder.get_compiled_handlebars(node.kind).call(render_context)
+    end
+  end
+end

data/lib/hiptest-publisher/renderer_addons/behave_addon.rb

@@ -0,0 +1,23 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module BehaveAddon
+    def walk_actionwords(aws)
+      base = super(aws)
+      sorted_aws = aws.children[:actionwords]
+        .sort_by {|aw|
+          pattern = aw.children.fetch(:gherkin_pattern, "")
+          [pattern.length, pattern]
+        }.reverse
+
+      @rendered_children[:sorted_actionwords] = sorted_aws.map {|aw| @rendered[aw]}
+      return base
+    end
+
+    private
+
+    def get_pattern(aw)
+      name = aw.children["name"]
+    end
+  end
+end

data/lib/hiptest-publisher/renderer_addons/gherkin_addon.rb

@@ -0,0 +1,59 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module GherkinAddon
+    def walk_call(call)
+      if call.free_text_arg
+        @rendered_children[:free_text_arg] = rendered_freetext_arg(call)
+      end
+
+      if call.datatable_arg
+        @rendered_children[:datatable_arg] = rendered_datatable_arg(call)
+      end
+
+      super(call)
+    end
+
+    def walk_actionword(aw)
+      parameters = aw.children[:parameters]
+      aw.chunks = replace_parameter_value_with_type(aw.chunks, parameters)
+      aw.extra_inlined_parameters = replace_parameter_value_with_type(aw.extra_inlined_parameters, parameters)
+
+      super(aw)
+    end
+
+    def walk_folder(folder)
+      @rendered_children[:ancestor_tags] = ancestor_tags(folder)
+
+      super(folder)
+    end
+
+    private
+
+    def rendered_datatable_arg(call)
+      @rendered[call.datatable_arg.children[:value]]
+    end
+
+    def rendered_freetext_arg(call)
+      @rendered[call.free_text_arg.children[:value]]
+    end
+
+    def ancestor_tags(folder)
+      ancestor_tags = folder.ancestors.map { |f| f.children[:tags] }.flatten.uniq
+      ancestor_tags.map { |t| Hiptest::Renderer.render(t, @context) }
+    end
+
+    def replace_parameter_value_with_type(collection, parameters)
+      collection.map do |obj|
+        if obj[:is_parameter]
+          parameter = parameters.find { |parameter| parameter.children[:name] == obj[:name] }
+          obj[:typed_value] = parameter ? "{#{parameter.type.downcase}}" : "{}"
+        else
+          obj[:typed_value] = obj[:value]
+        end
+
+        obj
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/renderer_addons/groovy_spock_addon.rb

@@ -0,0 +1,34 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module GroovySpockAddon
+    def walk_call(call)
+      base = super(call)
+      use_annotation(call, base)
+    end
+
+    private
+
+    def use_annotation(call, base)
+      base[:use_expect_annotation] = needs_fixing?(call)
+      base[:use_main_annotation?] = !(call.children[:annotation].nil? || ['and', 'but'].include?(call.children[:annotation]))
+
+      base
+    end
+
+    def needs_fixing?(call)
+      scenario = call.parent
+
+      return false unless scenario.is_a?(Hiptest::Nodes::Scenario)
+      return false unless call.children[:annotation].nil? || ignore_case_equal?(call.children[:annotation], 'then')
+
+      return call.parent.children[:body].select do |step|
+        step.is_a?(Hiptest::Nodes::Call) && !step.children[:annotation].nil? && ignore_case_equal?(step.children[:annotation], 'when')
+      end.empty?
+    end
+
+    def ignore_case_equal?(string1, string2)
+      string1.casecmp(string2) == 0
+    end
+  end
+end

data/lib/hiptest-publisher/renderer_addons/robot_framework_addon.rb

@@ -0,0 +1,42 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  module RobotFrameworkAddon
+    def walk_folder(folder)
+      walk_scenario_container(folder)
+      super(folder)
+    end
+
+    def walk_scenarios(scenarios)
+      walk_scenario_container(scenarios)
+      super(scenarios)
+    end
+
+    private
+
+    def walk_scenario_container(container)
+     # For Robot framework, we need direct access to every scenario
+     # datatables and body rendered.
+
+      @rendered_children[:splitted_scenarios] = container.children[:scenarios].map {|sc|
+        {
+          name: @rendered[sc.children[:name]],
+          tags: sc.children[:tags].map {|tag| @rendered[tag]},
+          uid: @rendered[sc.children[:uid]],
+          datatable: @rendered[sc.children[:datatable]],
+          datasets: sc.children[:datatable].children[:datasets].map {|dataset|
+            {
+              scenario_name: @rendered[sc.children[:name]],
+              name: @rendered[dataset.children[:name]],
+              uid: @rendered[dataset.children[:uid]],
+              test_snapshot_uid: @rendered[dataset.children[:test_snapshot_uid]],
+              arguments: @rendered[dataset.children[:arguments]]
+            }
+          },
+          parameters:  @rendered[sc.children[:parameters]],
+          body: @rendered[sc.children[:body]]
+        }
+      }
+    end
+  end
+end

data/lib/hiptest-publisher/renderer_addons.rb

@@ -0,0 +1,4 @@
+require 'hiptest-publisher/renderer_addons/behave_addon'
+require 'hiptest-publisher/renderer_addons/gherkin_addon'
+require 'hiptest-publisher/renderer_addons/groovy_spock_addon'
+require 'hiptest-publisher/renderer_addons/robot_framework_addon'

data/lib/hiptest-publisher/signature_differ.rb

@@ -0,0 +1,105 @@
+module Hiptest
+  class SignatureDiffer
+    def self.diff(old, current, library_name: nil)
+      SignatureDiffer.new(old, current).compute_diff(library_name)
+    end
+
+    def initialize(old, current)
+      @old = old
+      @current = current
+    end
+
+    def compute_diff(library_name = nil)
+      if library_name.nil?
+        @old_uid = map_by_uid(@old)
+        @current_uid = map_by_uid(@current)
+      else
+        @old_uid = map_by_uid(get_library_actionwords(@old, library_name))
+        @current_uid = map_by_uid(get_library_actionwords(@current, library_name))
+      end
+
+      compute_created
+      compute_deleted
+
+      compute_definition_changed
+      compute_signature_changed
+      compute_renamed
+
+      diff = {}
+      diff[:created] = @created unless @created.empty?
+      diff[:deleted] = @deleted unless @deleted.empty?
+      diff[:renamed] = @renamed unless @renamed.empty?
+      diff[:signature_changed] = @signature_changed unless @signature_changed.empty?
+      diff[:definition_changed] = @definition_changed unless @definition_changed.empty?
+
+      diff
+    end
+
+    private
+
+    def compute_created
+      @created_uids = @current_uid.keys - @old_uid.keys
+      @created = @created_uids.map {|uid| {name: @current_uid[uid]['name'], node: @current_uid[uid]['node']}}
+    end
+
+    def compute_deleted
+      @deleted_uids = @old_uid.keys - @current_uid.keys
+      @deleted = @deleted_uids.map {|uid| {name: @old_uid[uid]['name']}}
+    end
+
+    def compute_renamed
+      excluded = [
+        @created_uids,
+        @deleted_uids,
+        @definition_changed_uids,
+        @signature_changed_uids
+      ].flatten.uniq
+
+      @renamed = @current_uid.map do |uid, aw|
+        next if excluded.include?(uid)
+        next if @old_uid[uid]['name'] == aw['name']
+
+        {name: @old_uid[uid]['name'], new_name: aw['name'], node: aw['node']}
+      end.compact
+    end
+
+    def compute_signature_changed
+      excluded = [
+        @created_uids,
+        @deleted_uids,
+        @definition_changed_uids
+      ].flatten.uniq
+
+      @signature_changed_uids = []
+      @signature_changed = @current_uid.map do |uid, aw|
+        next if excluded.include?(uid)
+        next if @old_uid[uid]['parameters'] == aw['parameters']
+
+        @signature_changed_uids << uid
+        {name: aw['name'], node: aw['node']}
+      end.compact
+    end
+
+    def compute_definition_changed
+      @definition_changed_uids = []
+
+      @definition_changed = @current_uid.map do |uid, aw|
+        next if @old_uid[uid].nil?
+        next unless @old_uid[uid].has_key?('body_hash')
+        next if aw['body_hash'] == @old_uid[uid]['body_hash']
+
+        @definition_changed_uids << uid
+        {name: aw['name'], node: aw['node']}
+      end.compact
+    end
+
+    def get_library_actionwords(data, library_name)
+      library = data.select {|item| item['type'] == 'library' && item['name'] == library_name}.first
+      library.nil? ? [] : library['actionwords']
+    end
+
+    def map_by_uid(items)
+      Hash[items.reject {|item| item['type'] == 'library'}.collect { |aw| [aw['uid'], aw] }]
+    end
+  end
+end

data/lib/hiptest-publisher/signature_exporter.rb

@@ -0,0 +1,56 @@
+require 'yaml'
+require 'digest/md5'
+
+module Hiptest
+  class SignatureExporter
+    def self.export_actionwords(project, export_nodes = false)
+      exporter = SignatureExporter.new
+
+      [
+        exporter.export_actionwords(project.children[:actionwords], export_nodes),
+        exporter.export_libraries(project.children[:libraries], export_nodes)
+      ].flatten
+    end
+
+    def export_actionwords(aws, export_nodes = false)
+      aws.children[:actionwords].map {|aw| export_actionword(aw, export_nodes)}
+    end
+
+    def export_libraries(libraries, export_nodes = false)
+      libraries.children[:libraries].map {|lib| export_library(lib, export_nodes)}
+    end
+
+    def export_library(library, export_nodes = false)
+      {
+        'name' => library.children[:name],
+        'type' => 'library',
+        'actionwords' => library.children[:library_actionwords].map {|aw| export_actionword(aw, export_nodes) }
+      }
+    end
+
+    def export_actionword(item, export_node = false)
+      hash = {
+        'name' => item.children[:name],
+        'uid' => item.children[:uid],
+        'parameters' => export_parameters(item),
+        'body_hash' => make_body_hash(item.children[:body])
+      }
+      hash['node'] = item if export_node
+      hash
+    end
+
+    def export_parameters(item)
+      item.children[:parameters].map {|p| export_parameter(p)}
+    end
+
+    def export_parameter(parameter)
+      {
+        'name' => parameter.children[:name]
+      }
+    end
+
+    def make_body_hash(body)
+      Digest::MD5.hexdigest(body.map(&:flat_string).join(''))
+    end
+  end
+end