allure-cucumber 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjcyNWVjNzM4OWU1ZWNmOGM3MGEyMjA2MzA1ZDlkMTc0ZWFjNTNhYg==
+  data.tar.gz: !binary |-
+    ZTVlNjdlMjI5OWRlMjAxMzU0NGE0NjIzMDA4OWJjYmZhNTUwMzY1MQ==
+SHA512:
+  metadata.gz: !binary |-
+    MTAyZmU4ZDk3ZDNkOTgwNTQ3OWM1NDcwOTZlZTAxYTI0MmYyMmMyZjljMTJk
+    NTQwNjA1OGMzYjEyYzg0OWVlOGY3NzI2ZmNjMWY5YmE0NzI4NWYxZWZiNWZi
+    NTY2YTMzYzBlOWUzNGEzMzZhYWFhNzZmYmU4ZTI1Y2YzNTNmYWQ=
+  data.tar.gz: !binary |-
+    YWYyMjgzNGI0MWYxMjQyZTZmYmM2YjkzMGJmZTJjMDEzNGNiNTY0OTA2NjY4
+    ZTJmNjZmNTMzM2ViZWUxZjk1YzhhNWM3MTUwYzE4ZWU2NmJhZWQxNjliNjE1
+    ZDNhNWE4NmU4M2UxNTQ2YjgxYjk1NzlmZDkxN2FiYTkyMmQxZjA=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in allure-cucumber.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Imran
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# AllureCucumber
+
+Allure adaptor for [cucumber](http://cukes.info/). This borrows code heavily from [allure-rspec](https://github.com/allure-framework/allure-rspec) gem.
+This is an experimental gem and very much a work in progress.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'allure-cucumber'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install allure-cucumber
+
+## Usage
+
+Use `--format AllureCucumber::Formatter` while running cucumber or add it to `cucumber.yml`
+
+By default, allure artifacts are stored in `/allure/data`. To change this set `AllureCucumber::Config.output_dir = directory-for-allure-xml` in your `env.rb` file.
+
+You can attach files to steps 
+
+	```ruby
+	# file: features/support/env.rb
+
+	include AllureCucumber::DSL
+
+	attach_file(title, file)
+	```
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/allure-cucumber.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/allure-cucumber/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "allure-cucumber"
+  spec.version       = AllureCucumber::Version::STRING
+  spec.authors       = ["Imran Khan"]
+  spec.email         = ["9ikhan@gmail.com"]
+  spec.summary       = "allure-cucumber-#{AllureCucumber::Version::STRING}"
+  spec.description   = %q{Adaptor to use Allure framework with cucumber}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'nokogiri', '~> 1.6.0'
+  spec.add_dependency 'uuid'
+  spec.add_dependency 'mimemagic'
+  spec.add_dependency 'cucumber'
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+end

data/lib/allure-cucumber.rb

@@ -0,0 +1,29 @@
+require "allure-cucumber/version"
+require 'allure-cucumber/dsl'
+require 'allure-cucumber/builder'
+require 'allure-cucumber/formatter'
+require 'allure-cucumber/feature_tracker'
+
+
+module AllureCucumber
+
+  module Config
+    class << self
+      attr_accessor :output_dir
+      
+      DEFAULT_OUTPUT_DIR = 'allure/data'
+      
+      def output_dir
+        @output_dir || DEFAULT_OUTPUT_DIR
+      end
+
+    end 
+  end
+
+   class << self
+    def configure(&block)
+      yield Config
+    end
+   end
+
+end

data/lib/allure-cucumber/builder.rb

@@ -0,0 +1,164 @@
+require 'rexml/text'
+require 'nokogiri'
+
+module AllureCucumber
+
+  class Builder
+    class << self
+      attr_accessor :suites
+      MUTEX = Mutex.new
+      
+      def init_suites
+        MUTEX.synchronize {
+          self.suites ||= {}
+        }
+      end
+      
+      def start_suite(title)
+        init_suites
+        MUTEX.synchronize do
+          puts "Starting suite : #{title}"
+          self.suites[title] = {
+                                :title => title,
+                                :start => timestamp,
+                                :tests => {},
+                               }
+        end
+      end
+
+      def start_test(suite, test, severity = :normal)
+        MUTEX.synchronize do
+          puts "Starting test : #{test}"
+          self.suites[suite][:tests][test] = {
+                                              :title => test,
+                                              :start => timestamp,
+                                              :severity => severity,
+                                              :failure => nil,
+                                              :steps => {},
+                                              :attachments => []
+                                             }
+        end
+      end
+
+      def stop_test(suite, test, result = {})
+        self.suites[suite][:tests][test][:steps].each do |step_title, step|
+          if step[:stop].nil? || step[:stop] == 0
+            stop_step(suite, test, step_title, result[:status])
+          end
+        end
+        MUTEX.synchronize do
+          puts "Stopping test : #{test}"
+          self.suites[suite][:tests][test][:stop] = timestamp(result[:finished_at])
+          self.suites[suite][:tests][test][:start] = timestamp(result[:started_at])
+          self.suites[suite][:tests][test][:status] = result[:status]
+          if (result[:status].to_sym != :passed)
+            self.suites[suite][:tests][test][:failure] = {
+                                                          :stacktrace => escape((result[:caller] || []).map { |s| s.to_s }.join("\r\n")),
+                                                          :message => escape(result[:exception].to_s),
+                                                         } 
+          end
+
+        end
+      end
+
+      def escape(text)
+        text
+      end
+
+      def start_step(suite, test, step, time = nil, severity = :normal)
+        MUTEX.synchronize do
+          puts "Starting step : #{step}"
+          self.suites[suite][:tests][test][:steps][step] = {
+                                                            :title => step,
+                                                            :start => timestamp(time),
+                                                            :severity => severity || :normal,
+                                                            :attachments => []
+                                                           }
+        end
+      end
+
+      def add_attachment(suite, test, attachment, step = nil)
+        attach = {
+                  :title => attachment[:title],
+                  :source => attachment[:source],
+                  :type => attachment[:type],
+                  :size => attachment[:size],
+                 }
+        if step.nil?
+          self.suites[suite][:tests][test][:attachments] << attach
+        else
+          self.suites[suite][:tests][test][:steps][step][:attachments] << attach
+        end
+      end
+
+      def stop_step(suite, test, step, status = :passed, time = nil)
+        MUTEX.synchronize do
+          puts "Stopping step : #{step}"
+          self.suites[suite][:tests][test][:steps][step][:stop] = timestamp(time)
+          self.suites[suite][:tests][test][:steps][step][:status] = status
+        end
+      end
+
+      def stop_suite(title)
+        init_suites
+        MUTEX.synchronize do
+          puts "Stopping suite : #{title}"
+          self.suites[title][:stop] = timestamp
+        end
+      end
+
+      def timestamp(time = nil)
+        ((time || Time.now).to_f * 1000).to_i
+      end
+
+      def each_suite_build(&block)
+        suites_xml = []
+        self.suites.each do |suite_title, suite|
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.send "ns2:test-suite", :start => suite[:start] || 0, :stop => suite[:stop] || 0, 'xmlns' => '', "xmlns:ns2" => "urn:model.allure.qatools.yandex.ru" do
+              xml.send "name", suite_title
+              xml.send "test-cases" do
+                suite[:tests].each do |test_title, test|
+                  xml.send "test-case", :start => test[:start] || 0, :stop => test[:stop] || 0, :status => test[:status] do
+                    xml.send "name", test_title
+                    unless test[:failure].nil?
+                      xml.failure do
+                        xml.message test[:failure][:message]
+                        xml.send "stack-trace", test[:failure][:stacktrace]
+                      end
+                    end
+                    xml.steps do
+                      test[:steps].each do |step_title, step_obj|
+                        xml.step(:start => step_obj[:start] || 0, :stop => step_obj[:stop] || 0, :status => step_obj[:status]) do
+                          xml.send "name", step_title
+                          xml.attachments do
+                            step_obj[:attachments].each do |attach|
+                              xml.attachment :source => attach[:source], :title => attach[:title], :size => attach[:size], :type => attach[:type]
+                            end
+                          end
+                        end
+                      end
+                    end
+                    xml.attachments do
+                      test[:attachments].each do |attach|
+                        xml.attachment :source => attach[:source], :title => attach[:title], :size => attach[:size], :type => attach[:type]
+                      end
+                    end
+                    xml.labels do
+                      xml.label :name => "severity", :value => test[:severity]
+                    end
+                    xml.parameters
+                  end
+                end
+              end
+            end
+          end
+          xml = builder.to_xml
+          yield suite, xml
+          suites_xml << xml
+        end
+        suites_xml
+      end
+    end
+  end
+end

data/lib/allure-cucumber/dsl.rb

@@ -0,0 +1,23 @@
+require 'digest'
+require 'mimemagic'
+module AllureCucumber
+  module DSL
+
+    def attach_file(title, file)
+      @tracker = AllureCucumber::FeatureTracker.tracker
+      dir = Pathname.new(AllureCucumber::Config.output_dir)
+      FileUtils.mkdir_p(dir)
+      file_extname = File.extname(file.path.downcase)
+      type = MimeMagic.by_path(file.path) || "text/plain"
+      attachment = dir.join("#{Digest::SHA256.file(file.path).hexdigest}-attachment#{(file_extname.empty?) ? '' : file_extname}")
+      FileUtils.cp(file.path, attachment)
+      AllureCucumber::Builder.add_attachment(@tracker.feature_name, @tracker.scenario_name, {
+                                                                                             :type => type,
+                                                                                             :title => title,
+                                                                                             :source => attachment.basename,
+                                                                                             :size => File.stat(attachment).size
+                                                                                            }, @tracker.step_name)
+    end
+
+  end
+end

data/lib/allure-cucumber/feature_tracker.rb

@@ -0,0 +1,19 @@
+module AllureCucumber
+  
+  class FeatureTracker
+
+    attr_accessor :feature_name, :scenario_name, :step_name  
+    @@tracker = nil
+
+    def self.create
+      @@tracker = FeatureTracker.new unless @@tracker
+      private_class_method :new
+      @@tracker
+    end
+
+    def self.tracker
+      @@tracker
+    end
+    
+  end
+end

data/lib/allure-cucumber/formatter.rb

@@ -0,0 +1,186 @@
+require 'pathname'
+require 'uuid'
+
+module AllureCucumber
+  class Formatter
+
+    include AllureCucumber::DSL
+
+    def initialize(step_mother, io, options)
+      dir = Pathname.new(AllureCucumber::Config.output_dir)      
+      FileUtils.rm_rf(dir)
+      @tracker = AllureCucumber::FeatureTracker.create
+    end
+    
+    def before_feature(feature)
+      @has_background = false
+      @tracker.feature_name =  feature.name.gsub!(/\n/, " ")
+      AllureCucumber::Builder.start_suite(@tracker.feature_name)
+    end
+
+    def before_background(*args)
+      @in_background = true
+      @has_background = true
+      @background_before_steps = []
+      @background_after_steps = []
+    end
+
+    def after_background(*args)
+      @in_background = false
+    end
+
+    def before_feature_element(feature_element)
+      @scenario_outline = feature_element.instance_of?(Cucumber::Ast::ScenarioOutline) 
+    end
+
+    def scenario_name(keyword, name, file_colon_line, source_indent)
+      unless @scenario_outline
+        @tracker.scenario_name = (name.nil? || name == "") ? "Unnamed scenario" : name.split("\n")[0]
+        AllureCucumber::Builder.start_test(@tracker.feature_name, @tracker.scenario_name)
+        post_background_steps if  @has_background
+      else
+        @scenario_outline_name = (name.nil? || name == "") ? "Unnamed scenario" : name.split("\n")[0]
+      end      
+    end
+    
+    def before_steps(steps)
+      @example_before_steps = []
+      @example_after_steps = []
+      @exception = nil
+    end
+
+    def before_step(step)
+      unless step.background?
+        unless @scenario_outline
+          @tracker.step_name = step.name
+          AllureCucumber::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name) 
+          attach_multiline_arg(step.multiline_arg)
+        else
+          @example_before_steps << {:step => step, :time => Time.now}
+        end
+      else
+        @background_before_steps << {:step => step, :time => Time.now}
+      end
+    end
+
+    def after_step(step)
+      unless step.background? 
+        unless @scenario_outline
+          AllureCucumber::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)
+        else
+          @example_after_steps << {:step => step, :time => Time.now}
+        end
+      else
+        @background_after_steps << {:step => step, :time => Time.now}
+      end
+    end
+    
+    def after_steps(steps)
+      return if @in_background || @scenario_outline
+      result = { status: steps.status, exception: steps.exception }
+      AllureCucumber::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, result)
+    end
+
+    def before_examples(*args)
+      @header_row = true
+      @in_examples = true
+    end
+
+    def before_outline_table(outline_table)
+      headers = outline_table.headers
+      rows = outline_table.rows
+      @current_row = -1
+      @table = []
+      rows.each do |element|
+        row_hash = {}
+        element.each_with_index do |item, index|
+          row_hash[headers[index]] = item
+        end
+        @table << row_hash
+      end
+    end
+    
+    def before_table_row(table_row)
+      return unless @in_examples
+      unless @header_row
+        @scenario_status = :passed 
+        @exception = nil
+        @tracker.scenario_name = "#{@scenario_outline_name} Example: #{table_row.name}"
+        AllureCucumber::Builder.start_test(@tracker.feature_name, @tracker.scenario_name)
+        post_background_steps if @has_background
+        @current_row += 1
+        @example_before_steps.each do |step| 
+          @tracker.step_name = transform_step_name_for_outline(step[:step].name, @current_row)
+          AllureCucumber::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step[:time])
+          attach_multiline_arg(step[:step].multiline_arg)  
+        end
+      end
+    end
+    
+    def after_table_row(table_row)
+      return unless @in_examples or Cucumber::Ast::OutlineTable::ExampleRow === table_row
+      unless @header_row
+        @example_after_steps.each do |step| 
+          @tracker.step_name = transform_step_name_for_outline(step[:step].name, @current_row)
+          if table_row.status == :failed
+            @exception = table_row.exception
+            @scenario_status = :failed
+          end      
+          AllureCucumber::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step[:step].status.to_sym, step[:time])
+        end
+        AllureCucumber::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, {:status => @scenario_status, :exception => @exception})
+      end
+      @header_row = false if @header_row
+    end
+
+    def after_outline_table(*args)
+      @in_examples = false
+    end
+    
+    def after_feature(feature)
+      AllureCucumber::Builder.stop_suite(@tracker.feature_name)
+    end
+
+    def after_features(features)
+      AllureCucumber::Builder.each_suite_build do |suite, xml|
+        dir = Pathname.new(AllureCucumber::Config.output_dir)
+        FileUtils.mkdir_p(dir)
+        out_file = dir.join("#{UUID.new.generate}-testsuite.xml")
+        File.open(out_file, 'w+') do |file|
+          file.write(xml)
+        end
+      end
+    end
+    
+    private
+    
+    def transform_step_name_for_outline(step_name, row_num)
+      transformed_name = ''
+      @table[row_num].each do |k, v| 
+        transformed_name == '' ? transformed_name = step_name.gsub(k, v) : transformed_name = transformed_name.gsub(k,v)
+      end
+      transformed_name
+    end
+
+    def attach_multiline_arg(multiline_arg)
+      if multiline_arg
+        File.open('tmp_file.txt', 'w'){ |file| file.write(multiline_arg.to_s.gsub(/\e\[(\d+)(;\d+)*m/,'')) }
+        attach_file("table", File.open('tmp_file.txt'))
+      end
+    end
+
+    def post_background_steps
+      @background_before_steps.each do |step|
+        @tracker.step_name = "Background : #{step[:step].name}"
+        AllureCucumber::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step[:time])
+        attach_multiline_arg(step[:step].multiline_arg)
+      end
+      @background_before_steps.each do |step|
+        @tracker.step_name = "Background : #{step[:step].name}"
+        AllureCucumber::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step[:step].status.to_sym, step[:time])        
+        attach_multiline_arg(step[:step].multiline_arg)
+      end     
+    end
+    
+  end  
+end

data/lib/allure-cucumber/version.rb

@@ -0,0 +1,5 @@
+module AllureCucumber  
+  module Version 
+    STRING = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: allure-cucumber
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Imran Khan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mimemagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adaptor to use Allure framework with cucumber
+email:
+- 9ikhan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- allure-cucumber.gemspec
+- lib/allure-cucumber.rb
+- lib/allure-cucumber/builder.rb
+- lib/allure-cucumber/dsl.rb
+- lib/allure-cucumber/feature_tracker.rb
+- lib/allure-cucumber/formatter.rb
+- lib/allure-cucumber/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: allure-cucumber-0.1.0
+test_files: []