hiptest-publisher 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a5e8d4f38038c17b0009f6824c62008381c394d
+  data.tar.gz: c233e7e0b2947c037c04d2551509c3faf12cc4f4
+SHA512:
+  metadata.gz: 3f9a95295875103d1b18c083f98a99b85a113c5fc19344715c94ec9df2b9306b50e94fc467c5707d7c8cb68c513dfa0f8ba11174fbcb58e60bab2e174c8a4eef
+  data.tar.gz: ea856f6b89ba0c981b73768d7e5f1408782ea5a5c5d30bc291d0b10655e0a024962279873ff307ea97971fe8ac83dcebaf97db960622285917291a89f7c5bbb7

data/README.md

@@ -0,0 +1,98 @@
+Hiptest Publisher
+==============
+
+[![Build Status](https://travis-ci.org/Smartesting/zest-publisher.svg?branch=master)](https://travis-ci.org/Smartesting/zest-publisher)
+[![Gem version](https://badge.fury.io/rb/zest-publisher.svg)](http://badge.fury.io/rb/zest-publisher)
+[![Code climate](https://codeclimate.com/github/Smartesting/zest-publisher.png)](https://codeclimate.com/github/Smartesting/zest-publisher)
+[![Coverage](https://codeclimate.com/github/Smartesting/zest-publisher/coverage.png)](https://codeclimate.com/github/Smartesting/zest-publisher)
+[![Dependencies](https://gemnasium.com/Smartesting/zest-publisher.svg)](https://gemnasium.com/Smartesting/zest-publisher)
+
+
+Installing
+----------
+
+You need to have [Ruby installed on your machine](https://www.ruby-lang.org/en/installation/). You can then install it using gem:
+
+```shell
+gem install hiptest-publisher
+```
+
+Exporting a project
+-------------------
+
+Go to one of your [Hiptest projects](https://hiptest.net/#/projects) and select the Settings tab.
+This tab is available only for projects you own.
+From there, copy the secret token and run this command line:
+
+```shell
+hiptest-publisher --token=<YOUR TOKEN>
+```
+
+This will create a Ruby tests suite. For the moment, we support the following languages and frameworks:
+
+ - Ruby (rspec / minitest)
+ - Python (unittest)
+ - Java (JUnit)
+
+You can specify the output language and framework in the command line, for example:
+
+```shell
+hiptest-publisher --token=<YOUR TOKEN> --language=ruby --framework=minitest
+```
+
+
+For more information on the available options, use the following command:
+
+```shell
+hiptest-publisher --help
+```
+
+You could obtain for example:
+
+```shell
+Specific options:
+    -t, --token=TOKEN                Secret token (available in your project settings)
+    -l, --language=LANG              Target language (default: ruby)
+    -f, --framework=FRAMEWORK        Test framework to use
+    -o, --output-directory=PATH      Output directory (default: .)
+    -c, --config-file=PATH           Configuration file (default: config)
+        --scenario-ids=IDS           Filter scenarios by ids
+        --scenario-tags=TAGS         Filter scenarios by tags
+        --tests-only                 Export only the tests (default: false)
+        --actionwords-only           Export only the actionwords (default: false)
+        --split-scenarios            Export each scenario in a single file (default: false)
+        --leafless-export            Use only last level action word (default: false)
+    -s, --site=SITE                  Site to fetch from (default: https://hiptest.net)
+    -v, --verbose                    Run verbosely (default: false)
+    -H, --languages-help             Show languages and framework options
+    -F, --filters-help               Show help about scenario filtering
+    -h, --help                       Show this message
+```
+
+Configuration
+-------------
+
+You have the possibility to store some configuration in a file named 'config'. Copy the file config.sample provided here and update the values with the values you use.
+
+If you have multiple projects, you can have multiple config files and select one using the --config-file option:
+
+```shell
+# Use the default config file
+hiptest-publisher
+# Use the one to export as minitest
+hiptest-publisher --config-file=config_minitest
+```
+
+For example, for java you can use this config file content:
+
+```
+token = '<YOUR TOKEN>'
+language = 'java'
+output_directory = '<YOUR OUTPUT DIRECTORY>'
+package = 'com.youcompagny'
+```
+
+Adding support for other languages and framework
+------------------------------------------------
+
+See the [CONTRIBUTING](https://github.com/hiptest/hiptest-publisher/blob/master/docs/CONTRIBUTING.md>) help page for more information.

data/bin/hiptest-publisher

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+  gem 'hiptest-publisher'
+rescue LoadError
+end
+
+require 'hiptest-publisher'
+
+Hiptest::Publisher.new(ARGV).export

data/lib/hiptest-publisher.rb

@@ -0,0 +1,121 @@
+require 'colorize'
+
+require 'hiptest-publisher/string'
+require 'hiptest-publisher/utils'
+require 'hiptest-publisher/options_parser'
+require 'hiptest-publisher/xml_parser'
+require 'hiptest-publisher/parent_adder'
+require 'hiptest-publisher/parameter_type_adder'
+require 'hiptest-publisher/call_arguments_adder'
+
+module Hiptest
+  class Publisher
+    def initialize(args)
+      @options = OptionsParser.parse(args)
+
+      xml = fetch_xml_file
+      return if xml.nil?
+
+      @project = get_project(xml)
+    end
+
+    def fetch_xml_file
+      show_status_message "Fetching data from Hiptest"
+      xml = fetch_project_export(@options)
+      show_status_message "Fetching data from Hiptest", :success
+
+      return xml
+    rescue Exception => err
+      show_status_message "Fetching data from Hiptest", :failure
+      puts "Unable to open the file, please check that the token is correct".red
+      trace_exception(err) if @options.verbose
+    end
+
+    def get_project(xml)
+      show_status_message "Extracting data"
+      parser = Hiptest::XMLParser.new(xml, @options)
+      show_status_message "Extracting data", :success
+
+      return parser.build_project
+    end
+
+    def write_node_to_file(path, node, context, message)
+      status_message = "#{message}: #{path}"
+      begin
+        show_status_message status_message
+        File.open(path, 'w') do |file|
+          file.write(Hiptest::Renderer.render(node, @options.language, context))
+        end
+
+        show_status_message status_message, :success
+      rescue Exception => err
+        show_status_message status_message, :failure
+        trace_exception(err) if @options.verbose
+      end
+    end
+
+    def export_tests
+      if @options.split_scenarios
+        @project.children[:tests].children[:tests].each do |test|
+          context = @language_config.tests_render_context
+          context[:test_file_name] = @language_config.scenario_output_file(test.children[:name])
+
+          write_node_to_file(
+            @language_config.scenario_output_dir(test.children[:name]),
+            test,
+            context,
+            "Exporting test \"#{test.children[:name]}\"")
+        end
+      else
+        write_node_to_file(
+          @language_config.tests_output_dir,
+          @project.children[:tests],
+          @language_config.tests_render_context,
+          "Exporting tests")
+      end
+    end
+
+    def export_scenarios
+      if @options.split_scenarios
+        @project.children[:scenarios].children[:scenarios].each do |scenario|
+          context = @language_config.tests_render_context
+          context[:test_file_name] = @language_config.scenario_output_file(scenario.children[:name])
+
+          write_node_to_file(
+            @language_config.scenario_output_dir(scenario.children[:name]),
+            scenario,
+            context,
+            "Exporting scenario \"#{scenario.children[:name]}\"")
+        end
+      else
+        write_node_to_file(
+          @language_config.tests_output_dir,
+          @project.children[:scenarios],
+          @language_config.tests_render_context,
+          "Exporting scenarios")
+      end
+    end
+
+    def export_actionwords
+      write_node_to_file(
+        @language_config.aw_output_dir,
+        @project.children[:actionwords],
+        @language_config.actionword_render_context,
+        "Exporting actionwords"
+      )
+    end
+
+    def export
+      @language_config = LanguageConfigParser.new(@options)
+      Hiptest::Nodes::ParentAdder.add(@project)
+      Hiptest::Nodes::ParameterTypeAdder.add(@project)
+      Hiptest::DefaultArgumentAdder.add(@project)
+
+      unless @options.actionwords_only
+        @options.leafless_export ? export_tests : export_scenarios
+      end
+
+      export_actionwords unless @options.tests_only
+    end
+  end
+end

data/lib/hiptest-publisher/call_arguments_adder.rb

@@ -0,0 +1,63 @@
+require 'hiptest-publisher/nodes'
+
+module Hiptest
+  class DefaultArgumentAdder
+    def self.add(project)
+      DefaultArgumentAdder.new(project).update_calls
+    end
+
+    def initialize(project)
+      @project = project
+      @indexer = ActionwordIndexer.new(project)
+    end
+
+    def update_calls
+      @project.find_sub_nodes(Hiptest::Nodes::Call).each do |call|
+        aw_data = @indexer.get_index(call.children[:actionword])
+        next if aw_data.nil?
+
+        arguments = {}
+        call.children[:arguments].each do |arg|
+          arguments[arg.children[:name]] = arg.children[:value]
+        end
+
+        call.children[:all_arguments] = aw_data[:parameters].map do |p_name, default_value|
+          Hiptest::Nodes::Argument.new(
+            p_name,
+            arguments.has_key?(p_name) ? arguments[p_name] : default_value
+          )
+        end
+      end
+    end
+  end
+
+  class ActionwordIndexer
+    def initialize(project)
+      @project = project
+      @indexed = {}
+      index_actionwords
+    end
+
+    def index_actionwords
+      @project.find_sub_nodes(Hiptest::Nodes::Actionword).each do |aw|
+        aw_name = aw.children[:name]
+        indexed_parameters = {}
+
+        aw.children[:parameters].map do |param|
+          param_name = param.children[:name]
+          indexed_parameters[param_name] = param.children[:default]
+        end
+
+        @indexed[aw_name] = {
+          :actionword => aw,
+          :parameters => indexed_parameters
+        }
+
+      end
+    end
+
+    def get_index(name)
+      @indexed[name]
+    end
+  end
+end

data/lib/hiptest-publisher/handlebars_helper.rb

@@ -0,0 +1,97 @@
+module Hiptest
+  class HandlebarsHelper
+    def self.register_helpers(handlebars, context)
+      instance = Hiptest::HandlebarsHelper.new(handlebars, context)
+      instance.register_string_helpers
+      instance.register_custom_helpers
+    end
+
+    def initialize(handlebars, context)
+      @handlebars = handlebars
+      @context = context
+    end
+
+    def register_string_helpers
+      string_helpers = [
+        :literate,
+        :normalize,
+        :normalize_lower,
+        :underscore,
+        :camelize,
+        :camelize_lower,
+        :clear_extension
+      ]
+
+      string_helpers.each do |helper|
+        @handlebars.register_helper(helper) do |context, value|
+          "#{value.to_s.send(helper)}"
+        end
+      end
+    end
+
+    def register_custom_helpers
+      self.class.instance_methods.each do |method_name|
+        next unless method_name.to_s.start_with? 'hh_'
+        @handlebars.register_helper(method_name.to_s.gsub(/hh_/, '')) do |*args|
+          send(method_name, *args)
+        end
+      end
+    end
+
+    def hh_to_string(context, value, block)
+      "#{value.to_s}"
+    end
+
+    def hh_join(context, items, joiner, block)
+      joiner = "\t" if joiner == '\t'
+      "#{items.join(joiner)}"
+    end
+
+    def hh_indent(context, block)
+      indentation = @context[:indentation] || '  '
+      indentation = "\t" if indentation == '\t'
+
+      block.fn(context).split("\n").map do |line|
+        indented = "#{indentation}#{line}"
+        indented = "" if indented.strip.empty?
+        indented
+      end.join("\n")
+    end
+
+    def hh_clear_empty_lines(context, block)
+      block.fn(context).split("\n").map do |line|
+        line unless line.strip.empty?
+      end.compact.join("\n")
+    end
+
+    def hh_remove_quotes (context, s, block)
+      "#{s.gsub('"', '')}"
+    end
+
+    def hh_escape_quotes (context, s, block)
+      "#{s.gsub(/"/) {|_| '\\"' }}"
+    end
+
+    def hh_comment (context, commenter, block)
+      block.fn(context).split("\n").map do |line|
+        "#{commenter} #{line}"
+      end.join("\n")
+    end
+
+    def hh_curly (context, block)
+      "{#{block.fn(context)}}"
+    end
+
+    def hh_open_curly (context, block)
+      "{"
+    end
+
+    def hh_close_curly (context, block)
+      "}"
+    end
+
+    def hh_tab (context, block)
+      "\t"
+    end
+  end
+end

data/lib/hiptest-publisher/nodes.rb

@@ -0,0 +1,380 @@
+require 'hiptest-publisher/string'
+require 'hiptest-publisher/utils'
+require 'hiptest-publisher/renderer'
+
+module Hiptest
+  module Nodes
+    class Node
+      attr_reader :children, :parent
+      attr_writer :parent
+
+      def render(language = 'ruby', context = {})
+        return Hiptest::Renderer.render(self, language, context)
+      end
+
+      def find_sub_nodes(types = [])
+        sub_nodes = all_sub_nodes
+        types = [types] unless types.is_a?(Array)
+
+        if types.empty?
+          sub_nodes
+        else
+          sub_nodes.keep_if do |node|
+            types.map {|type| node.is_a?(type)}.include?(true)
+          end
+        end
+      end
+
+      def direct_children
+        direct = []
+
+        children.each do |key, child|
+          if child.is_a? Hiptest::Nodes::Node
+            direct << child
+          elsif child.is_a? Array
+            child.each {|c| direct << c if c.is_a? Hiptest::Nodes::Node }
+          end
+        end
+
+        direct
+      end
+
+      private
+
+      def all_sub_nodes
+        path = [self]
+        children = []
+
+        until path.empty?
+          current_node = path.pop
+
+          if current_node.is_a?(Node)
+            next if children.include? current_node
+
+            children << current_node
+            current_node.children.values.reverse.each {|item| path << item}
+          elsif current_node.is_a?(Array)
+            current_node.reverse.each {|item| path << item}
+          end
+        end
+        children
+      end
+    end
+
+    class Literal < Node
+      def initialize(value)
+        super()
+        @children = {:value => value}
+      end
+    end
+
+    class NullLiteral < Node
+      def initialize
+        super()
+        @children = {}
+      end
+    end
+
+    class StringLiteral < Literal
+    end
+
+    class NumericLiteral < Literal
+    end
+
+    class BooleanLiteral < Literal
+    end
+
+    class Variable < Node
+      def initialize(name)
+        super()
+        @children = {:name => name}
+      end
+    end
+
+    class Property < Node
+      def initialize(key, value)
+        super()
+        @children = {:key => key, :value => value}
+      end
+    end
+
+    class Field < Node
+      def initialize(base, name)
+        super()
+        @children = {:base => base, :name => name}
+      end
+    end
+
+    class Index < Node
+      def initialize(base, expression)
+        super()
+        @children = {:base => base, :expression => expression}
+      end
+    end
+
+    class BinaryExpression < Node
+      def initialize(left, operator, right)
+        super()
+        @children = {:operator => operator, :left => left, :right => right}
+      end
+    end
+
+    class UnaryExpression < Node
+      def initialize(operator, expression)
+        super()
+        @children = {:operator => operator, :expression => expression}
+      end
+    end
+
+    class Parenthesis < Node
+      def initialize(content)
+        super()
+        @children = {:content => content}
+      end
+    end
+
+    class List < Node
+      def initialize(items)
+        super()
+        @children = {:items => items}
+      end
+    end
+
+    class Dict < Node
+      def initialize(items)
+        super()
+        @children = {:items => items}
+      end
+    end
+
+    class Template < Node
+      def initialize(chunks)
+        super()
+        @children = {:chunks => chunks}
+      end
+    end
+
+    class Assign < Node
+      def initialize(to, value)
+        super()
+        @children = {:to => to, :value => value}
+      end
+    end
+
+    class Argument < Node
+      def initialize(name, value)
+        super()
+        @children = {:name => name, :value => value}
+      end
+    end
+
+    class Call < Node
+      def initialize(actionword, arguments = [])
+        super()
+        @children = {:actionword => actionword, :arguments => arguments}
+      end
+    end
+
+    class IfThen < Node
+      def initialize(condition, then_, else_ = [])
+        super()
+        @children = {:condition => condition, :then => then_, :else => else_}
+      end
+    end
+
+    class Step < Node
+      def initialize(key, value)
+        super()
+        @children = {:key => key, :value => value}
+      end
+    end
+
+    class While < Node
+      def initialize(condition, body)
+        super()
+        @children = {:condition => condition, :body => body}
+      end
+    end
+
+    class Tag < Node
+      def initialize(key, value = nil)
+        super()
+        @children = {:key => key, :value => value}
+      end
+    end
+
+    class Parameter < Node
+      def initialize(name, default = nil)
+        super()
+        @children = {:name => name, :default => default}
+      end
+
+      def type
+        if @children[:type].nil?
+          'String'
+        else
+          @children[:type].to_s
+        end
+      end
+    end
+
+    class Item < Node
+      attr_reader :variables, :non_valued_parameters, :valued_parameters
+
+      def initialize(name, tags = [], parameters = [], body = [])
+        super()
+        @children = {
+          :name => name,
+          :tags => tags,
+          :parameters => parameters,
+          :body => body
+        }
+      end
+    end
+
+    class Actionword < Item
+    end
+
+    class Scenario < Item
+      attr_reader :folder_uid
+
+      def initialize(name, description = '', tags = [], parameters = [], body = [], folder_uid = nil, datatable = Datatable.new)
+        super(name, tags, parameters, body)
+        @children[:description] = description
+        @children[:datatable] = datatable
+
+        @folder_uid = folder_uid
+      end
+    end
+
+    class Test < Node
+      def initialize(name, description = '', tags = [], body = [])
+        super()
+
+        @children = {
+          :name => name,
+          :description => description,
+          :tags => tags,
+          :body => body
+        }
+      end
+    end
+
+    class Datatable < Node
+      def initialize(datasets = [])
+        super()
+
+        @children = {
+          :datasets => datasets
+        }
+      end
+    end
+
+    class Dataset < Node
+      def initialize(name, arguments = [])
+        super()
+
+        @children = {
+          :name => name,
+          :arguments => arguments
+        }
+      end
+    end
+
+    class Actionwords < Node
+      def initialize(actionwords = [])
+        super()
+        @children = {:actionwords => actionwords}
+      end
+    end
+
+    class Scenarios < Node
+      def initialize(scenarios = [])
+        super()
+        @children = {:scenarios => scenarios}
+        scenarios.each {|sc| sc.parent = self}
+      end
+    end
+
+    class Tests < Node
+      def initialize(tests = [])
+        super()
+        @children = {:tests => tests}
+        tests.each {|test| test.parent = self}
+      end
+    end
+
+    class Folder < Node
+      attr_reader :uid, :parent, :parent_uid
+      attr_writer :parent
+
+      def initialize(uid, parent_uid, name)
+        super()
+
+        @uid = uid
+        @parent_uid = parent_uid
+
+        @children = {
+          :name => name,
+          :subfolders => [],
+          :scenarios => []
+        }
+      end
+    end
+
+    class TestPlan < Node
+      def initialize(folders = [])
+        super()
+        @uids_mapping = {}
+        @children = {
+          :root_folder => nil,
+          :folders => folders
+        }
+      end
+
+      def organize_folders
+        @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
+
+          folder.parent = parent
+          parent.children[:subfolders] << folder
+        end
+      end
+
+      def find_folder_by_uid(uid)
+        return @uids_mapping[uid]
+      end
+    end
+
+    class Project < Node
+      def initialize(name, description = '', test_plan = TestPlan.new, scenarios = Scenarios.new, actionwords = Actionwords.new, tests = Tests.new)
+        super()
+        scenarios.parent = self
+        tests.parent = self
+
+        @children = {
+          :name => name,
+          :description => description,
+          :test_plan => test_plan,
+          :scenarios => scenarios,
+          :actionwords => actionwords,
+          :tests => tests
+        }
+      end
+
+      def assign_scenarios_to_folders
+        @children[:scenarios].children[:scenarios].each do |scenario|
+          folder = @children[:test_plan].find_folder_by_uid(scenario.folder_uid)
+          next if folder.nil?
+
+          folder.children[:scenarios] << scenario
+        end
+      end
+    end
+  end
+end