hiptest-publisher 0.2.0

data/lib/hiptest-publisher/nodes_walker.rb

@@ -0,0 +1,45 @@
+module Hiptest
+  module Nodes
+    class Walker
+      def initialize(order = :parent_first)
+        @order = order
+      end
+
+      def walk_node(node)
+        self.send(@order, node)
+      end
+
+      private
+
+      def walk_children(node)
+        return unless node.is_a? Hiptest::Nodes::Node
+        node.children.values.each {|child| walk_node(child)}
+      end
+
+      def call_node_walker(node)
+        return unless node.is_a? Hiptest::Nodes::Node
+
+        node_class = node.class.name.split('::').last.downcase
+        walk_method_name = "walk_#{node_class}".to_sym
+
+        if self.methods.include? walk_method_name
+          self.send(walk_method_name, node)
+        end
+      end
+
+      def parent_first(node)
+        call_node_walker(node)
+        node.each {|item| walk_node(item)} if node.is_a? Array
+
+        walk_children(node)
+      end
+
+      def children_first(node)
+        walk_children(node)
+
+        node.each {|item| walk_node(item)} if node.is_a? Array
+        call_node_walker(node)
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/options_parser.rb

@@ -0,0 +1,225 @@
+require 'optparse'
+require 'parseconfig'
+require 'ostruct'
+
+require 'hiptest-publisher/utils'
+
+class FileConfigParser
+  def self.update_options(options)
+    config = ParseConfig.new(options.config)
+    config.get_params.each do |param|
+      options.send("#{param}=", config[param])
+    end
+    options
+
+  rescue Exception => err
+    trace_exception(err) if options.verbose
+    options
+  end
+end
+
+class Option
+  attr_reader :short, :long, :default, :type, :help, :attribute
+
+  def initialize(short, long, default, type, help, attribute)
+    @short = short
+    @long = long
+    @default = default
+    @type = type
+    @help = help
+    @attribute = attribute
+  end
+
+  def help
+    return @help if default.nil?
+
+    if @default.is_a? String
+      @default.empty? ? @help : "#{@help} (default: #{@default})"
+    else
+      "#{@help} (default: #{@default})"
+    end
+  end
+
+  def register(opts, options)
+    options[attribute] = @default unless default.nil?
+    on_values = [
+      @short ? "-#{@short}" : nil,
+      "--#{@long}",
+      @type,
+      help
+    ].compact
+
+    opts.on(*on_values) do |value|
+      options[attribute] = value
+    end
+  end
+end
+
+class OptionsParser
+  def self.languages
+    # First framework is default framework
+
+    {
+      'Ruby' => ['Rspec', 'MiniTest'],
+      'Java' => ['JUnit', 'Test NG'],
+      'Python' => ['Unittest'],
+      'Robot Framework' => [''],
+      'Selenium IDE' => ['']
+    }
+  end
+
+  def self.all_options
+    [
+      Option.new('t', 'token=TOKEN', nil, String, "Secret token (available in your project settings)", :token),
+      Option.new('l', 'language=LANG', 'ruby', String, "Target language", :language),
+      Option.new('f', 'framework=FRAMEWORK', '', String, "Test framework to use", :framework),
+      Option.new('o', 'output-directory=PATH', '.', String, "Output directory", :output_directory),
+      Option.new('c', 'config-file=PATH', 'config', String, "Configuration file", :config),
+      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, '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://www.hiptest-testing.com', String, "Site to fetch from", :site),
+      Option.new('v', 'verbose', false, nil, "Run verbosely", :verbose)
+    ]
+  end
+
+  def self.parse(args)
+    options = OpenStruct.new
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: ruby publisher.rb [options]"
+      opts.separator ""
+      opts.separator "Exports tests from Hiptest for automation."
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      all_options.each {|o| o.register(opts, options)}
+
+      opts.on("-H", "--languages-help", "Show languages and framework options") do
+        self.show_languages
+        exit
+      end
+
+      opts.on("-F", "--filters-help", "Show help about scenario filtering") do
+        [
+          "hiptest-publisher allows you to filter the exported scenarios.",
+          "You can select the ids of the scenarios:",
+          "hiptest-publisher --scenario-ids=12",
+          "hiptest-publisher --scenario-ids=12,15,16",
+          "",
+          "You can also filter by tags:",
+          "hiptest-publisher --scenario-tags=mytag",
+          "hiptest-publisher --scenario-tags=mytag,myother:tag",
+          "",
+          "You can not mix ids and tag filtering, only the id filtering will be applied."
+        ].each {|line| puts line}
+        exit
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+
+    opt_parser.parse!(args)
+    FileConfigParser.update_options options
+
+    show_options(options) if options.verbose
+    options
+  end
+
+  def self.show_options(options)
+    puts "Running Hiptest-publisher with:".yellow
+    options.marshal_dump.each { |k, v| puts " - #{k}: #{v}".white }
+  end
+
+  def self.make_language_option(lang, framework = '')
+    lang_opt = "--language=#{lang.downcase.gsub(' ', '')}"
+    framework_opt = "--framework=#{framework.downcase.gsub(' ', '')}"
+
+    framework.empty? ? lang_opt : "#{lang_opt} #{framework_opt}"
+  end
+
+  def self.show_languages
+    puts "Supported languages:"
+    languages.each do |language, frameworks|
+      puts "#{language}:"
+      if frameworks.empty?
+        puts "  no framework option available #{make_language_option(language, '')}"
+      else
+        frameworks.each_with_index do |fw, index|
+          if index == 0
+            puts " - #{fw} [default] #{make_language_option(language, '')}"
+          else
+            puts " - #{fw} #{make_language_option(language, fw)}"
+          end
+        end
+      end
+    end
+  end
+end
+
+class LanguageConfigParser
+  def initialize(options)
+    @options = options
+    @config = ParseConfig.new(find_config_file(options))
+  end
+
+  def find_config_file(options)
+    ["#{options.language}/#{options.framework}", "#{options.language}"].map do |p|
+      path = "#{hiptest_publisher_path}/lib/templates/#{p}/output_config"
+      path if File.file?(path)
+    end.compact.first
+  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])
+    else
+      scenario_name = scenario_name.normalize
+    end
+
+    @config['tests']['scenario_filename'].gsub('%s', scenario_name)
+  end
+
+  def scenario_output_dir(scenario_name)
+    "#{@options.output_directory}/#{scenario_output_file(scenario_name)}"
+  end
+
+  def tests_output_dir
+    "#{@options.output_directory}/#{@config['tests']['filename']}"
+  end
+
+  def aw_output_dir
+    "#{@options.output_directory}/#{@config['actionwords']['filename']}"
+  end
+
+  def tests_render_context
+    make_context('tests')
+  end
+
+  def actionword_render_context
+    make_context('actionwords')
+  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'
+    end
+
+    context[:package] = @options.package unless @options.package.nil?
+    context[:framework] = @options.framework unless @options.framework.nil?
+
+    @config[group].each {|param, value| context[param.to_sym] = value }
+    context
+  end
+end

data/lib/hiptest-publisher/parameter_type_adder.rb

@@ -0,0 +1,139 @@
+require 'hiptest-publisher/nodes_walker'
+
+module Hiptest
+  module Nodes
+    class ParameterTypeAdder < Hiptest::Nodes::Walker
+      attr_reader :call_types
+
+      def self.add(project)
+        walker = Hiptest::Nodes::ParameterTypeAdder.new
+        walker.walk_node(project)
+
+        Hiptest::Nodes::TypeWriter.new(walker.call_types).walk_node(project)
+      end
+
+      def initialize
+        super(:parent_first)
+      end
+
+      def walk_project(project)
+        @call_types = CallTypes.new
+      end
+
+      def walk_call(call)
+        @call_types.add_callable_item(call.children[:actionword])
+      end
+
+      def walk_argument(arg)
+        get_literal_values(arg).each {|value|
+          @call_types.add_argument(arg.children[:name], value[0], value[1])
+        }
+      end
+
+      def walk_actionword(actionword)
+        @call_types.add_callable_item(actionword.children[:name])
+      end
+
+      def walk_scenario(scenario)
+        @call_types.add_callable_item(scenario.children[:name])
+      end
+
+      private
+
+      def get_literal_values(node)
+        literals = node.find_sub_nodes([StringLiteral, NumericLiteral, BooleanLiteral])
+
+        return [[NullLiteral, nil]] if literals.empty?
+        literals.map {|literal| [literal.class, literal.children[:value]]}
+      end
+    end
+
+    class TypeWriter < Hiptest::Nodes::Walker
+      def initialize(call_types)
+        super(:parent_first)
+        @call_types = call_types
+        @callable_item_name = nil
+      end
+
+      def walk_actionword actionword
+        @callable_item_name = actionword.children[:name]
+      end
+
+      def walk_scenario(scenario)
+        @callable_item_name = scenario.children[:name]
+      end
+
+      def walk_parameter parameter
+        parameter.children[:type] = @call_types.type_of(@callable_item_name, parameter.children[:name])
+      end
+    end
+
+    class CallTypes
+      def initialize
+        @callable_items = {}
+        @current = nil
+      end
+
+      def select_callable_item(name)
+        @current = @callable_items[name]
+      end
+
+      def add_callable_item(name)
+        @callable_items[name] = {} unless @callable_items.keys.include?(name)
+        select_callable_item(name)
+      end
+
+      def add_argument(name, type, value)
+        add_parameter(name)
+        @current[name][:values] << {type: type, value: value}
+      end
+
+      def add_default_value(name, type, value)
+        add_parameter(name)
+        @current[name][:default] = {type: type, value: value}
+      end
+
+      def type_of(item_name, parameter_name)
+        return unless @callable_items.keys.include?(item_name)
+        parameter =  @callable_items[item_name][parameter_name]
+
+        return :String if parameter.nil? || parameter[:values].empty?
+        return type_from_values(parameter[:values])
+      end
+
+      private
+
+      def add_parameter(name)
+        return if @current.keys.include?(name)
+        @current[name] = {default: nil, values: []}
+      end
+
+      def type_from_values(values)
+        types = values.map {|val| val[:type] unless val[:type] == Hiptest::Nodes::NullLiteral}.compact.uniq
+
+        if types.empty?
+          :null
+        elsif types.length == 1
+          if types.first == Hiptest::Nodes::StringLiteral
+            :String
+          elsif types.first == Hiptest::Nodes::BooleanLiteral
+            :bool
+          elsif types.first == Hiptest::Nodes::NumericLiteral
+            determine_numeric(values)
+          end
+        else
+          :String
+        end
+      end
+
+      def determine_numeric(values)
+        types = values.map do |val|
+          next unless val[:type] == Hiptest::Nodes::NumericLiteral
+          return :float if val[:value].include?(".")
+        end.compact.uniq
+
+        :int
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/parent_adder.rb

@@ -0,0 +1,18 @@
+module Hiptest
+  module Nodes
+    class ParentAdder < Walker
+      def self.add(project)
+        Hiptest::Nodes::ParentAdder.new().walk_node(project)
+      end
+
+      def walk_node(node)
+        super(node)
+        return unless node.is_a? Hiptest::Nodes::Node
+
+        node.direct_children.each {|child|
+          child.parent = node
+        }
+      end
+    end
+  end
+end

data/lib/hiptest-publisher/render_context_maker.rb

@@ -0,0 +1,92 @@
+module Hiptest
+  module RenderContextMaker
+    def walk_item(item)
+      {
+        :has_parameters? => !item.children[:parameters].empty?,
+        :has_tags? => !item.children[:tags].empty?,
+        :has_step? => !item.find_sub_nodes(Hiptest::Nodes::Step).empty?,
+        :is_empty? => item.children[:body].empty?
+      }
+    end
+
+    alias :walk_actionword :walk_item
+
+    def walk_scenario(scenario)
+      base = walk_item(scenario)
+      base[:project_name] = scenario.parent.parent.children[:name]
+
+      datatable = scenario.children[:datatable]
+      base[:has_datasets?] = datatable ? !datatable.children[:datasets].empty? : false
+      return base
+    end
+
+    def walk_dataset(dataset)
+      datatable = dataset.parent
+      {
+        :scenario_name => datatable.parent.children[:name]
+      }
+    end
+
+    def walk_scenarios(scenarios)
+      {
+        :project_name => scenarios.parent.children[:name]
+      }
+    end
+
+    def walk_test(test)
+      {
+        :has_parameters? => false,
+        :has_tags? => !test.children[:tags].empty?,
+        :has_step? => !test.find_sub_nodes(Hiptest::Nodes::Step).empty?,
+        :is_empty? => test.children[:body].empty?,
+        :has_datasets? => false,
+        :project_name => test.parent.parent.children[:name],
+      }
+    end
+
+    def walk_tests(tests)
+      {
+        :project_name => tests.parent.children[:name]
+      }
+    end
+
+    def walk_call(c)
+      {
+        :has_arguments? => !c.children[:arguments].empty?
+      }
+    end
+
+    def walk_ifthen(it)
+      {
+        :has_else? => !it.children[:else].empty?
+      }
+    end
+
+    def walk_parameter(p)
+      {
+        :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
+  end
+end