allure-cucumber 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 213d515aaef5e471ee15dfb3a204f64aa8aa82a3
-  data.tar.gz: 74f5ec0d9571106fecceb3c5ef585e3c5b727498
+  metadata.gz: f342ba639e4ecb153d62562f75c474a849027308
+  data.tar.gz: a50a28d657b4b31178282d0c83d7416478a6ad0a
 SHA512:
-  metadata.gz: 8908351075d48e8834a1bc54abbfccda4ee8c7e60ccf7f0793866d8b8bb3cea4c6130def70c9d4e9fe398a2b833564c4c64c5ca20ddb8d041a3fe62558d6c261
-  data.tar.gz: e5100f6e83f4fdd668e913bfa3ec4e19824712ca870993ce58d815ccc50c3fc9c519bbb4d6990dce3a8fcabecc1dcdfe7a8a22d4ed37357957b17c70c3aa083f
+  metadata.gz: 2afa46d2a3f3cc34d6e162b9bdb897536e4433322d730966b48dee8f03b9654398654e09e412544903b44e62d44f1a27bf207f41dbebd9f83555e66fc235e65d
+  data.tar.gz: 8aa900d31952970d60b4dacbd6bad816d9ef6c47f6ee902a9927ceaca2ef417d9457531cb9a402fdb585fa349e3a4d9c66eb4a3ea4c00bf221b401843e449887

data/allure-cucumber.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'cucumber'
+  spec.add_dependency 'cucumber' , '>= 2.0.0'
   spec.add_dependency 'allure-ruby-adaptor-api'
 
   spec.add_development_dependency "bundler", "~> 1.5"

data/lib/allure-cucumber/dsl.rb

@@ -3,7 +3,12 @@ module AllureCucumber
 
     def attach_file(title, file)
       @tracker = AllureCucumber::FeatureTracker.tracker
-      AllureRubyAdaptorApi::Builder.add_attachment(@tracker.feature_name, @tracker.scenario_name, :step => @tracker.step_name, :file => file, :title => title)
+      if @tracker.scenario_name
+        AllureRubyAdaptorApi::Builder.add_attachment(@tracker.feature_name, @tracker.scenario_name, :step => @tracker.step_name, :file => file, :title => title)
+      else
+        # TODO: This is possible for background steps.  
+        puts "Cannot attach #{title} to step #{@tracker.step_name} as scenario name is undefined"
+      end
     end
 
   end

data/lib/allure-cucumber/feature_tracker.rb

@@ -2,7 +2,7 @@ module AllureCucumber
   
   class FeatureTracker
 
-    attr_accessor :feature_name, :scenario_name, :step_name, :scenario_started_at  
+    attr_accessor :feature_name, :scenario_name, :step_name
     @@tracker = nil
 
     def self.create

data/lib/allure-cucumber/formatter.rb

@@ -6,146 +6,100 @@ module AllureCucumber
   class Formatter
 
     include AllureCucumber::DSL
+    
+    TEST_HOOK_NAMES_TO_IGNORE = ['Before hook', 'After hook']
 
+    POSSIBLE_STATUSES = ['passed', 'failed', 'pending', 'skipped', 'undefined']
+    
     def initialize(step_mother, io, options)
       dir = Pathname.new(AllureCucumber::Config.output_dir)      
       FileUtils.rm_rf(dir)
+      FileUtils.mkdir_p(dir)
       @tracker = AllureCucumber::FeatureTracker.create
+      @deferred_before_test_steps = []
+      @deferred_after_test_steps = []
     end
     
+    # Start the test suite
     def before_feature(feature)
-      @has_background = false
       feature_identifier = ENV['FEATURE_IDENTIFIER'] && "#{ENV['FEATURE_IDENTIFIER']} - "
       @tracker.feature_name = "#{feature_identifier}#{feature.name.gsub(/\n/, " ")}"
-      AllureRubyAdaptorApi::Builder.start_suite(@tracker.feature_name, :severity => :normal)
-    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
+      AllureRubyAdaptorApi::Builder.start_suite(@tracker.feature_name)
     end
 
+    # Find sceanrio type
     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.gsub(/\n/, " ")
-        AllureRubyAdaptorApi::Builder.start_test(@tracker.feature_name, @tracker.scenario_name, :feature => @tracker.feature_name, :story => @tracker.scenario_name)
-        @tracker.scenario_started_at = Time.now
-        post_background_steps if  @has_background
-      else
-        @scenario_outline_name = (name.nil? || name == "") ? "Unnamed scenario" : name.gsub(/\n/, " ")
-      end      
+      @scenario_outline = feature_element.instance_of?(Cucumber::Core::Ast::ScenarioOutline)
     end
     
-    def before_steps(steps)
-      @example_before_steps = []
-      @example_after_steps = []
-      @exception = nil
+    def scenario_name(keyword, name, *args)
+      scenario_name = (name.nil? || name == "") ? "Unnamed scenario" : name.gsub(/\n/, " ")
+      @scenario_outline ? @scenario_outline_name = scenario_name : @tracker.scenario_name = scenario_name 
     end
 
-    def before_step(step)
-      unless step.background?
-        unless @scenario_outline
-          @tracker.step_name = step.name
-          AllureRubyAdaptorApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name) 
-          attach_multiline_arg(step.multiline_arg)
-        else
-          @example_before_steps << step
-        end
-      else
-        @background_before_steps << step
-      end
+    def before_examples(*args)
+      @header_row = true
+      @row_count = 0
     end
-
-    def after_step(step)
-      unless step.background?
-        unless @scenario_outline
-         AllureRubyAdaptorApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)
-        else
-          @example_after_steps << step
-        end
-      else
-        @background_after_steps << step
+    
+    # Start the test for normal scenarios
+    def before_steps(steps)
+      if !@scenario_outline  
+        start_test
       end
     end
     
+    # Stop the test for normal scenarios
     def after_steps(steps)
-      return if @in_background || @scenario_outline
-      result = { :status => steps.status, :exception => steps.exception, :started_at => @tracker.scenario_started_at, :finished_at => Time.now }
-      AllureRubyAdaptorApi::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, result)
-    end
-
-    def before_examples(*args)
-      @header_row = true
-      @in_examples = true
+      if !@scenario_outline 
+        result = test_result(steps)
+        stop_test(result)
+      end
     end
-
-    def before_examples(*args)
-      @header_row = true
-      @in_examples = true
+    
+    # Start the test for scenario examples
+    def before_table_row(table_row)
+      if @scenario_outline && !@header_row && !@in_multiline_arg
+        @row_count += 1
+        @tracker.scenario_name = "Example #{@row_count} : #{@scenario_outline_name}"
+        start_test
+      end
     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
+    # Stop the test for scenario examples 
+    def after_table_row(table_row)
+      unless @multiline_arg
+        if @scenario_outline && !@header_row 
+          result = test_result(table_row)
+          stop_test(result)
         end
-        @table << row_hash
+        @header_row = false
       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}"
-        AllureRubyAdaptorApi::Builder.start_test(@tracker.feature_name, @tracker.scenario_name, :feature => @tracker.feature_name, :story => @tracker.scenario_name)
-        @tracker.scenario_started_at = Time.now
-        post_background_steps if @has_background
-        @current_row += 1
-        @example_before_steps.each do |step| 
-          @tracker.step_name = transform_step_name_for_outline(step.name, @current_row)
-          AllureRubyAdaptorApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name)
-          attach_multiline_arg(step.multiline_arg)  
-        end
+    def before_test_step(test_step)
+      if !TEST_HOOK_NAMES_TO_IGNORE.include?(test_step.name) 
+        if @tracker.scenario_name
+          @tracker.step_name = test_step.name
+          start_step
+        else
+          @deferred_before_test_steps << {:step => test_step, :timestamp => Time.now}
+        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.name, @current_row)
-          if table_row.status == :failed
-            @exception = table_row.exception
-            @scenario_status = :failed
-          end      
-          AllureRubyAdaptorApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)
+    def after_test_step(test_step, result)
+      if !TEST_HOOK_NAMES_TO_IGNORE.include?(test_step.name) 
+        if @tracker.scenario_name
+          status = step_status(result)
+          stop_step(status)
+        else
+          @deferred_after_test_steps << {:step => test_step, :result => result, :timestamp => Time.now}
         end
-        AllureRubyAdaptorApi::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, {:status => @scenario_status, :exception => @exception, :started_at => @tracker.scenario_started_at, :finished_at => Time.now })
       end
-      @header_row = false if @header_row
     end
 
-    def after_outline_table(*args)
-      @in_examples = false
-    end
-    
+    # Stop the suite
     def after_feature(feature)
       AllureRubyAdaptorApi::Builder.stop_suite(@tracker.feature_name)
     end
@@ -154,35 +108,96 @@ module AllureCucumber
       AllureRubyAdaptorApi::Builder.build!
     end
     
+    def before_multiline_arg(multiline_arg)
+      @in_multiline_arg = true
+      # For background steps defer multiline attachment
+      if @tracker.scenario_name.nil?
+        @deferred_before_test_steps[-1].merge!({:multiline_arg => multiline_arg})
+      else
+        attach_multiline_arg_to_file(multiline_arg)
+      end
+    end
+
+    def after_multiline_arg(multiline_arg)
+      @in_multiline_arg = false
+    end
+    
     private
+
+    def step_status(result)
+      POSSIBLE_STATUSES.each do |status|
+        return cucumber_status_to_allure_status(status) if result.send("#{status}?")
+      end
+    end
     
-    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)
+    def test_result(result)
+      status = cucumber_status_to_allure_status(result.status)
+      exception = status == 'failed' && result.exception.nil? ? Exception.new("Some steps were undefined") : result.exception
+      if exception 
+        return {:status => status, :exception => exception}
+      else
+        return {:status => status}
       end
-      transformed_name
+    end
+    
+    def cucumber_status_to_allure_status(status)
+      case status.to_s
+      when "undefined"
+        return "failed"
+      when "skipped"
+        return "pending"
+      else
+        return status.to_s
+      end
+    end
+    
+    def attach_multiline_arg_to_file(multiline_arg)
+      dir = File.expand_path(AllureCucumber::Config.output_dir)
+      out_file = "#{dir}/#{UUID.new.generate}.txt"     
+      File.open(out_file, "w+") { |file| file.write(multiline_arg.to_s.gsub(/\e\[(\d+)(;\d+)*m/,'')) }
+      attach_file("multiline_arg", File.open(out_file))
     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'))
+    def start_test
+      if @tracker.scenario_name
+        AllureRubyAdaptorApi::Builder.start_test(@tracker.feature_name, @tracker.scenario_name, :feature => @tracker.feature_name, :story => @tracker.scenario_name)
+        post_deferred_steps
       end
     end
 
-    def post_background_steps
-      @background_before_steps.each do |step|
-        @tracker.step_name = "Background : #{step.name}"
-        AllureRubyAdaptorApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name)
-        attach_multiline_arg(step.multiline_arg)
+    def post_deferred_steps
+      @deferred_before_test_steps.size.times do |index|
+        @tracker.step_name = @deferred_before_test_steps[index][:step].name 
+        start_step
+        multiline_arg = @deferred_before_test_steps[index][:multiline_arg]
+        attach_multiline_arg_to_file(multiline_arg) if multiline_arg
+        if index < @deferred_after_test_steps.size
+          result = step_status(@deferred_after_test_steps[index][:result])
+          stop_step(result)
+        end
       end
-      @background_before_steps.each do |step|
-        @tracker.step_name = "Background : #{step.name}"
-        AllureRubyAdaptorApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, @tracker.step_name, step.status.to_sym)        
-        attach_multiline_arg(step.multiline_arg)
-      end     
+    end
+    
+    def stop_test(result)
+      if @deferred_before_test_steps != []
+        result[:started_at] = @deferred_before_test_steps[0][:timestamp]
+      end
+      if @tracker.scenario_name
+        AllureRubyAdaptorApi::Builder.stop_test(@tracker.feature_name, @tracker.scenario_name, result)
+        @tracker.scenario_name = nil
+        @deferred_before_test_steps = []
+        @deferred_after_test_steps = []
+      end
+    end
+    
+    def start_step(step_name = @tracker.step_name)
+      AllureRubyAdaptorApi::Builder.start_step(@tracker.feature_name, @tracker.scenario_name, step_name) 
+    end
+
+    def stop_step(status, step_name = @tracker.step_name)
+      AllureRubyAdaptorApi::Builder.stop_step(@tracker.feature_name, @tracker.scenario_name, step_name, status) 
     end
     
   end  
 end
+

data/lib/allure-cucumber/version.rb

@@ -1,5 +1,5 @@
 module AllureCucumber  
   module Version 
-    STRING = '0.4.4'
+    STRING = '0.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allure-cucumber
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - Imran Khan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-04 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: allure-ruby-adaptor-api
   requirement: !ruby/object:Gem::Requirement
@@ -104,8 +104,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: allure-cucumber-0.4.4
+summary: allure-cucumber-0.5.0
 test_files: []