cutara 0.0.1

data/lib/CucumberTarantulaFormatter.rb

@@ -0,0 +1,287 @@
+# -*- encoding : utf-8 -*-
+require 'fileutils'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'gherkin/formatter/escaping'
+require 'TarantulaUpdater'
+require 'Helper'
+
+module Cucumber
+  module Formatter
+    # This formatter prints features to plain text - exactly how they were parsed,
+    # just prettier. That means with proper indentation and alignment of table columns.
+    # it also updates Tarantula step results
+    #
+    # If the output is STDOUT (and not a file), there are bright colours to watch too.
+    #
+    module Duration
+      # Helper method for formatters that need to
+      # format a duration in seconds to the UNIX
+      # <tt>time</tt> format.
+      def format_duration_simple(seconds)
+        seconds
+      end
+    end
+    class CustomTarantulaFormatter
+      include FileUtils
+      include Console
+      include Io
+      include Gherkin::Formatter::Escaping
+      attr_writer :indent
+      attr_reader :runtime
+
+      def initialize(runtime, path_or_io, options)
+        @runtime, @io, @options = runtime, ensure_io(path_or_io, "pretty"), options
+        @exceptions = []
+        @indent = 0
+        @prefixes = options[:prefixes] || {}
+        @delayed_messages = []
+        @feature_name = nil
+        @scenario_index = 0
+        @scenario_exceptions = []
+        @scenario_undefined = false
+        @scenario_updated = false
+        TarantulaUpdater.config = YAML.load(File.open(SUPPORT+"/tarantula.yml"))
+      end
+
+      def after_features(features)
+        print_summary(features) unless @options[:autoformat]
+        @io.puts(format_duration_simple(features.duration)) if features && features.duration
+        resp = TarantulaUpdater.update_testcase_duration(ENV["project"], ENV["execution"], @feature_name, format_duration_simple(features.duration)) if features && features.duration
+        @io.puts ">>>>>>>>>>>>>>>" + resp.to_s
+      end
+
+      def before_feature(feature)
+        @scenario_index = 0
+        @exceptions = []
+        @indent = 0
+        if @options[:autoformat]
+          file = File.join(@options[:autoformat], feature.file)
+          dir = File.dirname(file)
+          mkdir_p(dir) unless File.directory?(dir)
+          @io = ensure_file(file, "pretty")
+        end
+      end
+
+      def comment_line(comment_line)
+        @io.puts(comment_line.indent(@indent))
+        @io.flush
+      end
+
+      def after_tags(tags)
+        if @indent == 1
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def tag_name(tag_name)
+        tag = format_string(tag_name, :tag).indent(@indent)
+        @io.print(tag)
+        @io.flush
+        @indent = 1
+      end
+
+      def feature_name(keyword, name)
+        @feature_name = name
+        @io.puts("#{keyword}: #{name}")
+        @io.puts
+        @io.flush
+      end
+
+      def before_feature_element(feature_element)
+        @indent = 2
+        @scenario_indent = 2
+      end
+
+      def after_feature_element(feature_element)
+        @io.puts
+        @io.flush
+      end
+
+      def before_background(background)
+        @indent = 2
+        @scenario_indent = 2
+        @in_background = true
+      end
+
+      def after_background(background)
+        @in_background = nil
+        @io.puts
+        @io.flush
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_examples_array(examples_array)
+        @indent = 4
+        @io.puts
+        @visiting_first_example_name = true
+      end
+
+      def examples_name(keyword, name)
+        @io.puts unless @visiting_first_example_name
+        @visiting_first_example_name = false
+        names = name.strip.empty? ? [name.strip] : name.split("\n")
+        @io.puts("    #{keyword}: #{names[0]}")
+        names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
+        @io.flush
+        @indent = 6
+        @scenario_indent = 6
+      end
+
+      def before_outline_table(outline_table)
+        @table = outline_table
+      end
+
+      def after_outline_table(outline_table)
+        @table = nil
+        @indent = 4
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        @scenario_index += 1
+        @scenario_exceptions = []
+        @scenario_undefined = false
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_step(step)
+        @current_step = step
+        @indent = 6
+      end
+
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        @hide_this_step = false
+        if exception
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
+          @exceptions << exception
+          @scenario_exceptions << exception
+        end
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
+        end
+        if status == :undefined
+          @scenario_undefined = true
+        end
+        @status = status
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+        return if @hide_this_step
+        source_indent = nil unless @options[:source]
+        name_to_report = format_step(keyword, step_match, status, source_indent)
+        @io.puts(name_to_report.indent(@scenario_indent + 2))
+        print_messages
+      end
+
+      def doc_string(string)
+        return if @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, @current_step.status))
+        @io.flush
+      end
+
+      def exception(exception, status)
+        return if @hide_this_step
+        print_exception(exception, status, @indent)
+        @io.flush
+      end
+
+      def before_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @hide_this_step
+        @table = multiline_arg
+      end
+
+      def after_multiline_arg(multiline_arg)
+        @table = nil
+      end
+
+      def before_table_row(table_row)
+        return if !@table || @hide_this_step
+        @col_index = 0
+        @io.print '  |'.indent(@indent-2)
+      end
+
+      def after_table_row(table_row)
+        return if !@table || @hide_this_step
+        print_table_row_messages
+        @io.puts
+        if table_row.exception && !@exceptions.include?(table_row.exception)
+          print_exception(table_row.exception, table_row.status, @indent)
+        end
+      end
+
+      def after_table_cell(cell)
+        return unless @table
+        @col_index += 1
+      end
+
+      def table_cell_value(value, status)
+        return if !@table || @hide_this_step
+        status ||= @status || :passed
+        width = @table.col_width(@col_index)
+        cell_text = escape_cell(value.to_s || '')
+        padded = cell_text + (' ' * (width - cell_text.unpack('U*').length))
+        prefix = cell_prefix(status)
+        @io.print(' ' + format_string("#{prefix}#{padded}", status) + ::Cucumber::Term::ANSIColor.reset(" |"))
+        @io.flush
+      end
+
+      def after_steps(steps)
+        return if @scenario_updated
+        result = "PASSED"
+        message = ''
+        position = @scenario_index
+        if not @scenario_exceptions.empty?
+          result = "FAILED"
+          message = @scenario_exceptions.inspect
+          @scenario_updated = true
+        elsif @scenario_undefined
+          result = "NOT_IMPL"
+          message = "Undefined cucumber sentence found"
+          @scenario_updated = true
+        end
+        if @in_background
+          message += " !INSIDE BACKGROUND!"
+          position = 1
+        end
+        resp = TarantulaUpdater.update_testcase_step(ENV["project"], ENV["execution"], @feature_name, position, result, message)
+        @io.puts ">>>>>>>>>>>>>>>" + resp.to_s
+      end
+
+      private
+
+      def print_feature_element_name(keyword, name, file_colon_line, source_indent)
+        @io.puts if @scenario_indent == 6
+        names = name.empty? ? [name] : name.split("\n")
+        line = "#{keyword}: #{names[0]}".indent(@scenario_indent)
+        @io.print(line)
+        if @options[:source]
+          line_comment = " # #{file_colon_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        names[1..-1].each {|s| @io.puts "    #{s}"}
+        @io.flush
+      end
+
+      def cell_prefix(status)
+        @prefixes[status]
+      end
+
+      def print_summary(features)
+        print_stats(features, @options)
+        print_snippets(@options)
+        print_passing_wip(@options)
+      end
+    end
+  end
+end

data/lib/Exceptions.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+module Cutara
+  class ExecutionStepError < StandardError; end
+end

data/lib/Helper.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+require 'babosa'
+
+ROOT = Dir.pwd + "/features"
+PAGES = ROOT + "/pages"
+STEPS = ROOT + "/step_definitions"
+SUPPORT = ROOT + "/support"
+ASSETS = File.dirname(__FILE__)+"/../assets"
+
+class String
+  @supported_languages = [:english,:bulgarian,:danish,:german,:greek,:macedonian,:norwegian,:romanian,:russian,:serbian,:spanish,:swedish,:ukrainian]
+  @@label_language = :russian
+
+  def self.label_language=(l)
+    raise ArgumentError, "unsupported language, supported languages: #{@supported_languages.inspect}\nmore: https://github.com/norman/babosa.git"\
+    unless @supported_languages.include? l
+    @@label_language = l
+  end
+
+  def self.label_language
+    @@label_language
+  end
+
+  def to_label
+    if String.label_language == :english
+      return self.to_slug.to_ruby_method.downcase
+    else
+      return self.to_slug.transliterate(String.label_language).to_ruby_method.downcase
+    end
+  end
+  
+  def to_action
+    'fire_'+self.to_label
+  end
+
+  def to_validator
+    'validate_'+self.to_label
+  end
+
+  def to_input
+    'feed_'+self.to_label
+  end
+
+  def to_press_action
+    'press_'+self.to_label
+  end
+
+  def to_select
+    'select_from_'+self.to_label
+  end
+
+  def to_each
+    self.to_label+'_each'
+  end
+
+  def to_open_subpage
+    self.to_label+'_open'
+  end
+
+  def to_params
+    params = {}
+    self.split(",").collect(&:strip).sort.each{|p|
+      params[p.split("=")[0].strip.to_sym] = p.split("=")[1].strip
+    }
+    params
+  end
+end
+
+class Dir
+  def recursive_each &block
+    self.each do |dir|
+      dirpath = self.path + '/' + dir
+      if File.directory?(dirpath) then
+        if dir != '.' && dir != '..' then
+          Dir.new(dirpath).recursive_each &block
+        end
+      else
+        block.call dirpath
+      end
+    end
+  end
+end

data/lib/TarantulaUpdater.rb

@@ -0,0 +1,62 @@
+require "active_support/core_ext/hash"
+require 'httparty'
+require 'Helper'
+
+class TarantulaUpdater
+  include HTTParty
+
+  @config = nil
+  # debug_output $stdout
+  headers  'Content-type' => 'application/xml', 'Accept' => 'application/xml' 
+
+  def self.config= hash
+    @config = hash
+  end
+
+  def self.get_tests options 
+    options = options.merge({ "language" => @config["language"] })
+    params = { 
+      :basic_auth => { :username => @config["username"], :password => @config["password"] },
+      :body => options.to_xml(:skip_types => true, :root => "request")
+    }
+    response = self.post(@config["server"]+'/api/get_scenarios', params)
+    raise response.body unless response.code == 200
+    response
+  end
+
+  def self.update_testcase_step(project, execution, testcase, step_position, result, comment)
+    body = {      
+        :project => project,
+        :execution => execution,
+        :testcase => testcase,
+        :position => step_position,
+        :result => result,
+        :comment => comment,
+      }.to_xml(:skip_types => true, :root => "request")
+
+    params = { 
+      :basic_auth => { :username => @config["username"], :password => @config["password"] },
+      :body => body
+    }
+    response = self.post(@config["server"]+'/api/update_testcase_step', params)
+    raise response.body unless response.code == 200
+    response
+  end
+
+  def self.update_testcase_duration(project, execution, testcase, duration)
+    body = {      
+        :project => project,
+        :execution => execution,
+        :testcase => testcase,
+        :duration => duration
+      }.to_xml(:skip_types => true, :root => "request")
+
+    params = { 
+      :basic_auth => { :username => @config["username"], :password => @config["password"] },
+      :body => body
+    }
+    response = self.post(@config["server"]+'/api/update_testcase_duration', params)
+    raise response.body unless response.code == 200
+    response
+  end
+end

data/lib/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+module Cutara
+  VERSION = "0.0.1"
+end

data/tasks/build.rake

@@ -0,0 +1,43 @@
+require 'TarantulaUpdater'
+require 'Helper'
+require "rexml/document"
+include REXML
+include FileUtils::Verbose
+
+@lang = YAML.load(File.open(SUPPORT+"/tarantula.yml"))["language"] if File.exist? SUPPORT+'/tarantula.yml'
+namespace "cutara" do
+  desc "Builds cucumber project"
+  task :build, [:project, :testcase, :execution] => :download do
+    mkdir_p(PAGES) unless File.exists?(PAGES)
+    mkdir_p(STEPS) unless File.exists?(STEPS)
+    cp "#{ASSETS}/env.rb", SUPPORT
+    steps_source = ASSETS + "/step_definitions/" + @lang
+    Dir.glob("#{steps_source}/*") {|f| cp File.expand_path(f), STEPS }
+  end
+
+  desc "Downloads cucumber scenarios from tarantula"
+  task :download, :project, :testcase, :execution do |t, args|
+    raise "arguments: [project*,testcase,execution]" if args.empty?
+
+    unless File.exist?(SUPPORT+"/tarantula.yml")
+      mkdir_p(SUPPORT) unless File.exists?(SUPPORT) # including ROOT dir
+      cp "#{ASSETS}/tarantula.yml", SUPPORT
+      raise "Please update #{SUPPORT}/tarantula.yml and rerun the task"
+    end
+    TarantulaUpdater.config = YAML.load(File.open(SUPPORT+"/tarantula.yml"))
+    query = {}
+    args.each{ |k,v| query[k.to_s]=v }
+    resp = TarantulaUpdater.get_tests(query)
+    resp = REXML::Document.new resp.body
+    resp.elements.each('test/test') do |test|
+      title = test.elements['title'].text
+      body = test.elements['body'].text
+      file = File.new(ROOT+"/#{title.to_label}.feature", "w+")
+      file.puts "# language: #{@lang}"
+      file.puts body
+      file.close
+    end
+  end
+
+end
+