allure-cucumber 0.1.0 → 0.2.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjcyNWVjNzM4OWU1ZWNmOGM3MGEyMjA2MzA1ZDlkMTc0ZWFjNTNhYg==
+    YWIzOGZmYmEzYTVhOTk4ZjczMzU0NjU5NTE5ZWFlOWMwMjc1OTExNA==
   data.tar.gz: !binary |-
-    ZTVlNjdlMjI5OWRlMjAxMzU0NGE0NjIzMDA4OWJjYmZhNTUwMzY1MQ==
+    MGNmN2NhNTRiMjg2NjA5YjA5NWFlZjc0ZGQxNDNiOTZiY2FlOTg2OA==
 SHA512:
   metadata.gz: !binary |-
-    MTAyZmU4ZDk3ZDNkOTgwNTQ3OWM1NDcwOTZlZTAxYTI0MmYyMmMyZjljMTJk
-    NTQwNjA1OGMzYjEyYzg0OWVlOGY3NzI2ZmNjMWY5YmE0NzI4NWYxZWZiNWZi
-    NTY2YTMzYzBlOWUzNGEzMzZhYWFhNzZmYmU4ZTI1Y2YzNTNmYWQ=
+    NWU4YzM4Y2ZmMDVlM2E4NDYyODlhN2ZhMTAyYjRlNDA1ODBkYjQzYWM4ZDA5
+    OWZmZTg3MzA1YWQwYjcxZjY1ZjYxNzgzZDg5ZGJmN2RmZjQ1NDMwNjQ0NGZm
+    NDIxYWZmZTIwN2I5NjI4NWMzNjMxNWQyNzJiYmZkZGVhMjZlZmU=
   data.tar.gz: !binary |-
-    YWYyMjgzNGI0MWYxMjQyZTZmYmM2YjkzMGJmZTJjMDEzNGNiNTY0OTA2NjY4
-    ZTJmNjZmNTMzM2ViZWUxZjk1YzhhNWM3MTUwYzE4ZWU2NmJhZWQxNjliNjE1
-    ZDNhNWE4NmU4M2UxNTQ2YjgxYjk1NzlmZDkxN2FiYTkyMmQxZjA=
+    NTI3OTI3Y2Q4ZTNmNzY3NjkzZjVlOGM1YzI2NGVkMDkzMjUwZTA4MzA0MGE3
+    YzAyMjc3NGM0ZTdkZDkyYmZlZmFmZGI3OTgwODRjM2RlZmIwMDIyMjNkYjk5
+    MWRkYzdiMjZlZjEwYjI3MmY2ZTBlZjRjM2ZmOGJiZmE2NDZjMzQ=

data/README.md

@@ -21,15 +21,15 @@ Or install it yourself as:
 
 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.
+By default, allure artifacts are stored in `/allure/data`. To change this set `AllureCucumber::Config.output_dir` in your `env.rb` file.
 
 You can attach files to steps 
 
-	```ruby
+```ruby
 	# file: features/support/env.rb
 
 	include AllureCucumber::DSL
 
 	attach_file(title, file)
-	```
+```
 

data/allure-cucumber.gemspec

@@ -16,10 +16,8 @@ Gem::Specification.new do |spec|
   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_dependency 'allure-ruby-api'
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"

data/lib/allure-cucumber.rb

@@ -1,9 +1,7 @@
 require "allure-cucumber/version"
-require 'allure-cucumber/dsl'
-require 'allure-cucumber/builder'
 require 'allure-cucumber/formatter'
 require 'allure-cucumber/feature_tracker'
-
+require 'allure-cucumber/dsl'
 
 module AllureCucumber
 

data/lib/allure-cucumber/dsl.rb

@@ -1,22 +1,9 @@
-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)
+      AllureRubyApi::Builder.add_attachment(@tracker.feature_name, @tracker.scenario_name, :step => @tracker.step_name, :file => file, :title => title)
     end
 
   end

data/lib/allure-cucumber/formatter.rb

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'uuid'
+require 'allure-ruby-api'
 
 module AllureCucumber
   class Formatter
@@ -9,13 +10,16 @@ module AllureCucumber
     def initialize(step_mother, io, options)
       dir = Pathname.new(AllureCucumber::Config.output_dir)      
       FileUtils.rm_rf(dir)
+      AllureRubyApi.configure do |c|
+        c.output_dir = dir
+      end
       @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)
+      AllureRubyApi::Builder.start_suite(@tracker.feature_name, :severity => :normal)
     end
 
     def before_background(*args)
@@ -36,7 +40,7 @@ module AllureCucumber
     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)
+        AllureRubyApi::Builder.start_test(@tracker.feature_name, @tracker.scenario_name, :feature => @tracker.feature_name, :story => @tracker.scenario_name)
         post_background_steps if  @has_background
       else
         @scenario_outline_name = (name.nil? || name == "") ? "Unnamed scenario" : name.split("\n")[0]
@@ -53,32 +57,37 @@ module AllureCucumber
       unless step.background?
         unless @scenario_outline
           @tracker.step_name = step.name
-          AllureCucumber::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name) 
+          AllureRubyApi::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}
+          @example_before_steps << step
         end
       else
-        @background_before_steps << {:step => step, :time => Time.now}
+        @background_before_steps << step
       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)
+         AllureRubyApi::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}
+          @example_after_steps << step
         end
       else
-        @background_after_steps << {:step => step, :time => Time.now}
+        @background_after_steps << step
       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)
+      AllureRubyApi::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, result)
+    end
+
+    def before_examples(*args)
+      @header_row = true
+      @in_examples = true
     end
 
     def before_examples(*args)
@@ -106,13 +115,13 @@ module AllureCucumber
         @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)
+        AllureRubyApi::Builder.start_test(@tracker.feature_name, @tracker.scenario_name, :feature => @tracker.feature_name, :story => @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)  
+          @tracker.step_name = transform_step_name_for_outline(step.name, @current_row)
+          AllureRubyApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name)
+          attach_multiline_arg(step.multiline_arg)  
         end
       end
     end
@@ -121,14 +130,14 @@ module AllureCucumber
       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)
+          @tracker.step_name = transform_step_name_for_outline(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])
+          AllureRubyApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)
         end
-        AllureCucumber::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, {:status => @scenario_status, :exception => @exception})
+        AllureRubyApi::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, {:status => @scenario_status, :exception => @exception})
       end
       @header_row = false if @header_row
     end
@@ -138,18 +147,11 @@ module AllureCucumber
     end
     
     def after_feature(feature)
-      AllureCucumber::Builder.stop_suite(@tracker.feature_name)
+      AllureRubyApi::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
+      AllureRubyApi::Builder.build!
     end
     
     private
@@ -171,14 +173,14 @@ module AllureCucumber
 
     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)
+        @tracker.step_name = "Background : #{step.name}"
+        AllureRubyApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name)
+        attach_multiline_arg(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)
+        @tracker.step_name = "Background : #{step.name}"
+        AllureRubyApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)        
+        attach_multiline_arg(step.multiline_arg)
       end     
     end
     

data/lib/allure-cucumber/version.rb

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

metadata

@@ -1,45 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: allure-cucumber
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Imran Khan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-25 00:00:00.000000000 Z
+date: 2014-08-05 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
+  name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -53,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: cucumber
+  name: allure-ruby-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -108,7 +80,6 @@ files:
 - 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
@@ -136,5 +107,6 @@ rubyforge_project:
 rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
-summary: allure-cucumber-0.1.0
+summary: allure-cucumber-0.2.1
 test_files: []
+has_rdoc: 

data/lib/allure-cucumber/builder.rb

@@ -1,164 +0,0 @@
-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