hiptest-publisher 0.5.10 → 0.6.0

data/lib/hiptest-publisher/cli_options_checker.rb

@@ -0,0 +1,107 @@
+
+
+
+class CliOptionsChecker
+  attr_reader :reporter, :cli_options
+  def initialize(cli_options, reporter)
+    @cli_options = cli_options
+    @reporter = reporter
+  end
+
+  def bad_arguments?
+    # ensure config file was readable if specified
+    begin
+      ParseConfig.new(cli_options.config) if present?(cli_options.config)
+    rescue Errno::EACCES => err
+      puts "Error with --config: the file \"#{cli_options.config}\" does not exist or is not readable"
+      return true
+    end
+
+    if cli_options.only == 'list'
+      return
+    end
+
+    unless cli_options.push.nil? || cli_options.push.empty?
+      return
+    end
+
+    # secret token
+    if missing?(cli_options.token) || empty?(cli_options.token)
+      puts "Missing argument --token: you must specify project secret token with --token=<project-token>"
+      puts ""
+      puts "The project secret token can be found on Hiptest in the settings section, under"
+      puts "'Publication settings'. It is a sequence of numbers uniquely identifying your"
+      puts "project."
+      puts ""
+      puts "Note that settings section is available only to administrators of the project."
+      return true
+    end
+
+    unless numeric?(cli_options.token)
+      puts "Invalid format --token=\"#{@cli_options.token}\": the project secret token must be numeric"
+      return true
+    end
+
+    # output directory
+    parent = first_existing_parent(cli_options.output_directory)
+    if !parent.writable?
+      if parent.realpath === Pathname.new(cli_options.output_directory).cleanpath
+        puts "Error with --output-directory: the directory \"#{@cli_options.output_directory}\" is not writable"
+      else
+        puts "Error with --output-directory: the directory \"#{@cli_options.output_directory}\" can not be created because \"#{parent.realpath}\" is not writable"
+      end
+      return true
+    elsif !parent.directory?
+      puts "Error with --output-directory: the file \"#{@cli_options.output_directory}\" is not a directory"
+      return true
+    end
+
+    # actionwords signature file
+    if cli_options.actionwords_diff || cli_options.aw_deleted || cli_options.aw_created || cli_options.aw_renamed || cli_options.aw_signature_changed
+      actionwords_signature_file = Pathname.new(cli_options.output_directory).join("actionwords_signature.yaml")
+      if actionwords_signature_file.directory?
+        puts "Bad Action Words signature file: the file \"#{actionwords_signature_file.realpath}\" is a directory"
+        return true
+      elsif !actionwords_signature_file.exist?
+        full_path = File.expand_path(cli_options.output_directory)
+        puts "Missing Action Words signature file: the file \"actionwords_signature.yaml\" could not be found in directory \"#{full_path}\""
+        puts "Use --actionwords-signature to generate the file \"#{full_path}/actionwords_signature.yaml\""
+        return true
+      end
+    end
+
+    # test run id
+    if present?(cli_options.test_run_id) && !numeric?(cli_options.test_run_id)
+      puts "Invalid format --test-run-id=\"#{@cli_options.test_run_id}\": the test run id must be numeric"
+      return true
+    end
+
+    return false
+  end
+
+  private
+
+  def numeric?(arg)
+    arg =~ /^\d*$/
+  end
+
+  def missing?(arg)
+    arg.nil?
+  end
+
+  def empty?(arg)
+    arg.strip.empty?
+  end
+
+  def present?(arg)
+    arg && !arg.strip.empty?
+  end
+
+  def first_existing_parent(path)
+    pathname = Pathname.new(path)
+    while !pathname.exist?
+      pathname = pathname.parent
+    end
+    pathname.realpath
+  end
+end

data/lib/hiptest-publisher/handlebars_helper.rb

@@ -116,4 +116,4 @@ module Hiptest
       ""
     end
   end
-end
+end

data/lib/hiptest-publisher/nodes.rb

@@ -14,8 +14,8 @@ module Hiptest
         super - [:@parent] # do not overload pry output
       end
 
-      def render(language = 'ruby', context = {})
-        return Hiptest::Renderer.render(self, language, context)
+      def render(rendering_context)
+        return Hiptest::Renderer.render(self, rendering_context)
       end
 
       def find_sub_nodes(types = [])
@@ -49,6 +49,14 @@ module Hiptest
         other.class == self.class && other.children == @children
       end
 
+      def project
+        project = self
+        while project && !project.is_a?(Hiptest::Nodes::Project)
+          project = project.parent
+        end
+        project
+      end
+
       private
 
       def all_sub_nodes
@@ -278,6 +286,10 @@ module Hiptest
       def set_uid(uid)
         @children[:uid] = uid
       end
+
+      def folder
+        project && project.children[:test_plan] && project.children[:test_plan].find_folder_by_uid(folder_uid)
+      end
     end
 
     class Test < Node
@@ -291,6 +303,10 @@ module Hiptest
           :body => body
         }
       end
+
+      def folder
+        nil
+      end
     end
 
     class Datatable < Node
@@ -358,10 +374,9 @@ module Hiptest
     end
 
     class Folder < Node
-      attr_reader :uid, :parent, :parent_uid
-      attr_writer :parent
+      attr_reader :uid, :parent_uid
 
-      def initialize(uid, parent_uid, name)
+      def initialize(uid, parent_uid, name, description)
         super()
 
         @uid = uid
@@ -369,10 +384,19 @@ module Hiptest
 
         @children = {
           :name => name,
+          :description => description,
           :subfolders => [],
           :scenarios => []
         }
       end
+
+      def root?
+        parent_uid == nil
+      end
+
+      def folder
+        root? ? nil : parent
+      end
     end
 
     class TestPlan < Node
@@ -386,16 +410,19 @@ module Hiptest
       end
 
       def organize_folders
+        @children[:root_folder] = @children[:folders].find(&:root?)
+        @children[:root_folder].parent = self if @children[:root_folder]
+
         @children[:folders].each do |folder|
           @uids_mapping[folder.uid] = folder
-          parent = find_folder_by_uid folder.parent_uid
-          if parent.nil?
-            @children[:root_folder] = folder
-            next
-          end
+        end
+
+        @children[:folders].each do |folder|
+          next if folder.root?
 
+          parent = find_folder_by_uid(folder.parent_uid) || @children[:root_folder]
           folder.parent = parent
-          parent.children[:subfolders] << folder
+          parent.children[:subfolders] << folder unless parent.children[:subfolders].include?(folder)
         end
       end
 
@@ -407,6 +434,7 @@ module Hiptest
     class Project < Node
       def initialize(name, description = '', test_plan = TestPlan.new, scenarios = Scenarios.new, actionwords = Actionwords.new, tests = Tests.new)
         super()
+        test_plan.parent = self if test_plan.respond_to?(:parent=)
         scenarios.parent = self
         tests.parent = self
 

data/lib/hiptest-publisher/nodes_walker.rb

@@ -22,7 +22,7 @@ module Hiptest
         node_class = node.class.name.split('::').last.downcase
         walk_method_name = "walk_#{node_class}".to_sym
 
-        if self.methods.include? walk_method_name
+        if respond_to? walk_method_name
           self.send(walk_method_name, node)
         end
       end
@@ -42,4 +42,4 @@ module Hiptest
       end
     end
   end
-end
+end

data/lib/hiptest-publisher/options_parser.rb

@@ -80,14 +80,16 @@ class OptionsParser
       Option.new(nil, 'test-run-id=ID', '', String, "Export data from a test run", :test_run_id),
       Option.new(nil, 'scenario-ids=IDS', '', String, "Filter scenarios by ids", :filter_ids),
       Option.new(nil, 'scenario-tags=TAGS', '', String, "Filter scenarios by tags", :filter_tags),
-      Option.new(nil, 'tests-only', false, nil, "Export only the tests", :tests_only),
-      Option.new(nil, 'actionwords-only', false, nil, "Export only the actionwords", :actionwords_only),
-      Option.new(nil, 'actionwords-signature', false, nil, "Export actionword signature", :actionwords_signature),
+      Option.new(nil, 'only=CATEGORIES', nil, String, "Restrict export to given file categories (--only=list to list them)", :only),
+      Option.new(nil, 'tests-only', false, nil, "(deprecated) alias for --only=tests", :tests_only),
+      Option.new(nil, 'actionwords-only', false, nil, "(deprecated) alias for --only=actionwords", :actionwords_only),
+      Option.new(nil, 'actionwords-signature', false, nil, "Export actionwords signature", :actionwords_signature),
       Option.new(nil, 'show-actionwords-diff', false, nil, "Show actionwords diff since last update (summary)", :actionwords_diff),
       Option.new(nil, 'show-actionwords-deleted', false, nil, "Output signature of deleted action words", :aw_deleted),
       Option.new(nil, 'show-actionwords-created', false, nil, "Output code for new action words", :aw_created),
       Option.new(nil, 'show-actionwords-renamed', false, nil, "Output signatures of renamed action words", :aw_renamed),
       Option.new(nil, 'show-actionwords-signature-changed', false, nil, "Output signatures of action words for which signature changed", :aw_signature_changed),
+      Option.new(nil, 'with-folders', false, nil, "Use folders hierarchy to export files in respective directories, to be used with --split-scenarios", :with_folders),
       Option.new(nil, 'split-scenarios', false, nil, "Export each scenario in a single file", :split_scenarios),
       Option.new(nil, 'leafless-export', false, nil, "Use only last level action word", :leafless_export),
       Option.new('s', 'site=SITE', 'https://hiptest.net', String, "Site to fetch from", :site),
@@ -171,54 +173,309 @@ class OptionsParser
   end
 end
 
-class LanguageConfigParser
-  def initialize(options, language_config_path = nil)
-    @options = options
-    language_config_path ||= LanguageConfigParser.config_path_for(options)
-    @config = ParseConfig.new(language_config_path)
+
+class NodeRenderingContext
+
+  def initialize(properties)
+    # should contain  :node, :path, :template_dirs, :description, :indentation
+    @properties = OpenStruct.new(properties)
   end
 
-  def self.config_path_for(options)
-    config_path = ["#{options.language}/#{options.framework}", "#{options.language}"].map do |p|
-      path = "#{hiptest_publisher_path}/lib/templates/#{p}/output_config"
-      File.expand_path(path) if File.file?(path)
+  def method_missing(name, *)
+    @properties[name]
+  end
+
+  def node
+    @properties.node
+  end
+
+  def [](key)
+    @properties[key]
+  end
+
+  def has_key?(key)
+    @properties.respond_to?(key)
+  end
+
+  def filename
+    File.basename(@properties.path)
+  end
+end
+
+
+class TemplateFinder
+  attr_reader :language, :framework, :overriden_templates, :forced_templates, :fallback_template
+
+  def initialize(
+      language: "ruby",
+      framework: nil,
+      overriden_templates: nil,
+      indentation: '  ',
+      forced_templates: nil,
+      fallback_template: nil,
+      **)
+    @language = language
+    @framework = framework
+    @overriden_templates = overriden_templates
+    @compiled_handlebars = {}
+    @forced_templates = forced_templates || {}
+    @fallback_template = fallback_template
+    @context = {indentation: indentation}
+  end
+
+  def dirs
+    dirs = []
+    dirs << "#{language}/#{framework}" if framework
+    dirs << language
+    dirs << "common"
+    dirs.map! { |path| "#{hiptest_publisher_path}/lib/templates/#{path}" }
+
+    dirs.unshift(overriden_templates) if overriden_templates
+    dirs
+  end
+
+  def get_compiled_handlebars(template)
+    @compiled_handlebars[template] ||= handlebars.compile(File.read(template))
+  end
+
+  def get_template_by_name(name, extension)
+    return if name.nil?
+    dirs.map do |path|
+      template_path = File.join(path, "#{name}.#{extension}")
+      template_path if File.file?(template_path)
     end.compact.first
-    if config_path.nil?
-      message = "cannot find output_config file in \"#{hiptest_publisher_path}/lib/templates\" for language #{options.language.inspect}"
-      message << " and framework #{options.framework.inspect}" if options.framework
-      raise ArgumentError.new(message)
+  end
+
+  def get_template_path(template_name, extension = 'hbs')
+    get_template_by_name(template_name, extension) || get_template_by_name(@fallback_template, extension)
+  end
+
+  def get_template(template_name, extension = 'hbs')
+    template_file = get_template_path(template_name, extension = 'hbs')
+    if template_file
+      get_compiled_handlebars(template).call(render_context)
+    else
+      raise ArgumentError.new("no template with name #{template_name}")
     end
-    config_path
   end
 
-  def scenario_output_file(scenario_name)
-    if make_context('tests').has_key? :class_name_convention
-      scenario_name = scenario_name.send(make_context('tests')[:class_name_convention])
+  def register_partials
+    dirs.reverse.each do |path|
+      next unless File.directory?(path)
+      Dir.entries(path).select do |file_name|
+        file_path = File.join(path, file_name)
+        next unless File.file?(file_path) && file_name.start_with?('_')
+        @handlebars.register_partial(file_name[1..-5], File.read(file_path))
+      end
+    end
+  end
+
+  private
+
+  def handlebars
+    if !@handlebars
+      @handlebars = Handlebars::Handlebars.new
+      register_partials
+      Hiptest::HandlebarsHelper.register_helpers(@handlebars, @context)
+    end
+    @handlebars
+  end
+end
+
+class LanguageGroupConfig
+  def initialize(user_params, language_group_params = nil)
+    @output_directory = user_params.output_directory || ""
+    @split_scenarios = user_params.split_scenarios
+    @with_folders = user_params.with_folders
+    @leafless_export = user_params.leafless_export
+    @user_language = user_params.language
+    @user_framework = user_params.framework
+    @language_group_params = language_group_params || {}
+  end
+
+  def [](key)
+    @language_group_params[key]
+  end
+
+  def with_folders?
+    @with_folders
+  end
+
+  def splitted_files?
+    if self[:scenario_filename].nil?
+      false
+    elsif self[:filename].nil?
+      true
+    else
+      @split_scenarios
+    end
+  end
+
+  def nodes(project)
+    case node_name
+    when :tests, :scenarios, :actionwords
+      get_children(project, node_name)
+    when :folders
+      project.children[:test_plan].children[:folders].select {|folder| folder.children[:scenarios].length > 0}
+    end
+  end
+
+  def forced_templates
+    forced = {}
+    if splitted_files?
+      forced.merge!(
+        "scenario" => "single_scenario",
+        "test" => "single_test",
+      )
+    end
+    if @language_group_params[:forced_templates]
+      forced.merge!(@language_group_params[:forced_templates])
+    end
+    forced
+  end
+
+  def template_finder
+    @template_finder ||= TemplateFinder.new(
+      language: @language_group_params[:language] || @user_language,
+      framework: @language_group_params[:framework] || @user_framework,
+      overriden_templates: @language_group_params[:overriden_templates],
+      indentation: indentation,
+      forced_templates: forced_templates,
+      fallback_template: @language_group_params[:fallback_template],
+    )
+  end
+
+  def template_dirs
+    template_finder.dirs
+  end
+
+  def each_node_rendering_context(project)
+    return to_enum(:each_node_rendering_context, project) unless block_given?
+    nodes(project).each do |node|
+      yield build_node_rendering_context(node)
+    end
+  end
+
+  def indentation
+    @language_group_params[:indentation] || '  '
+  end
+
+  def build_node_rendering_context(node)
+    path = File.join(@output_directory, output_file(node))
+
+    if splitted_files?
+      description = "#{singularize(node_name)} \"#{node.children[:name]}\""
     else
-      scenario_name = scenario_name.normalize
+      description = node_name.to_s
     end
 
-    @config['tests']['scenario_filename'].gsub('%s', scenario_name)
+    NodeRenderingContext.new(
+      path: path,
+      indentation: indentation,
+      template_dirs: template_dirs,
+      template_finder: template_finder,
+      forced_templates: forced_templates,
+      description: description,
+      node: node,
+      fallback_template: @language_group_params[:fallback_template],
+      call_prefix: @language_group_params[:call_prefix],
+      package: @language_group_params[:package],
+    )
   end
 
-  def scenario_output_dir(scenario_name)
-    "#{@options.output_directory}/#{scenario_output_file(scenario_name)}"
+  def output_directory(node)
+    folder = node.folder
+    hierarchy = []
+    while folder && !folder.root?
+      hierarchy << normalized_filename(folder.children[:name])
+      folder = folder.parent
+    end
+    File.join(*hierarchy.reverse)
   end
 
-  def tests_output_dir
-    "#{@options.output_directory}/#{@config['tests']['filename']}"
+  def output_file(node)
+    if splitted_files?
+      name = normalized_filename(node.children[:name])
+      filename = self[:scenario_filename].gsub('%s', name)
+      directory = with_folders? ? output_directory(node) : ""
+      File.join(directory, filename)
+    else
+      self[:filename]
+    end
   end
 
-  def aw_output_dir
-    "#{@options.output_directory}/#{@config['actionwords']['filename']}"
+  private
+
+  def node_name
+    if self[:node_name] == "tests" || self[:node_name] == "scenarios" || self[:group_name] == "tests"
+      @leafless_export ? :tests : :scenarios
+    elsif self[:node_name] == "actionwords" || self[:group_name] == "actionwords"
+      :actionwords
+    elsif self[:node_name] == "folders"
+      :folders
+    else
+      raise "Invalid node_name #{self[:node_name]} in language group [#{self[:group_name]}]"
+    end
   end
 
-  def tests_render_context
-    make_context('tests')
+  def get_children(project, node_key)
+    if splitted_files?
+      project.children[node_key].children[node_key]
+    else
+      [project.children[node_key]]
+    end
   end
 
-  def actionword_render_context
-    make_context('actionwords')
+  def normalized_filename(name)
+    filename_convention = @language_group_params[:filename_convention] || :normalize
+    name.send(filename_convention)
+  end
+end
+
+
+class LanguageConfigParser
+  def initialize(cli_options, language_config_path = nil)
+    @cli_options = cli_options
+    language_config_path ||= LanguageConfigParser.config_path_for(cli_options)
+    @config = ParseConfig.new(language_config_path)
+  end
+
+  def self.config_path_for(cli_options)
+    config_path = [
+      "#{hiptest_publisher_path}/lib/config/#{cli_options.language}-#{cli_options.framework}.conf",
+      "#{hiptest_publisher_path}/lib/config/#{cli_options.language}.conf",
+    ].map do |path|
+      File.expand_path(path) if File.file?(path)
+    end.compact.first
+    if config_path.nil?
+      message = "cannot find configuration file in \"#{hiptest_publisher_path}/config\" for language #{cli_options.language.inspect}"
+      message << " and framework #{cli_options.framework.inspect}" if cli_options.framework
+      raise ArgumentError.new(message)
+    end
+    config_path
+  end
+
+  def group_names
+    @config.groups.reject {|group_name|
+      group_name.start_with?('_')
+    }
+  end
+
+  def filtered_group_names
+    if @cli_options.only
+      groups_to_keep = @cli_options.only.split(",")
+      group_names.select {|group_name| groups_to_keep.include?(group_name)}
+    else
+      group_names
+    end
+  end
+
+  def include_group?(group_name)
+    filtered_group_names.include?(group_name)
+  end
+
+  def language_group_configs
+    filtered_group_names.map { |group_name| make_language_group_config(group_name) }
   end
 
   def name_action_word(name)
@@ -226,24 +483,26 @@ class LanguageConfigParser
   end
 
   private
-  def make_context group
-    context = {
-      :forced_templates => {}
-    }
 
-    if @options.split_scenarios
-      context[:forced_templates]['scenario'] = 'single_scenario'
-      context[:forced_templates]['test'] = 'single_test'
+  def group_config(group_name)
+    if @config[group_name]
+      @config[group_name].map { |key, value| [key.to_sym, value] }.to_h
+    else
+      {}
     end
+  end
 
-    context[:package] = @options.package unless @options.package.nil?
-    context[:framework] = @options.framework unless @options.framework.nil?
+  def make_language_group_config group_name
+    language_group_params = group_config('_common')
+    language_group_params.merge!(group_config(group_name))
+    language_group_params[:group_name] = group_name
+    language_group_params[:package] = @cli_options.package if @cli_options.package
+    language_group_params[:framework] = @cli_options.framework if @cli_options.framework
 
-    unless @options.overriden_templates.nil? || @options.overriden_templates.empty?
-      context[:overriden_templates] = @options.overriden_templates
+    unless @cli_options.overriden_templates.nil? || @cli_options.overriden_templates.empty?
+      language_group_params[:overriden_templates] = @cli_options.overriden_templates
     end
 
-    @config[group].each {|param, value| context[param.to_sym] = value }
-    context
+    LanguageGroupConfig.new(@cli_options, language_group_params)
   end
 end