allure-cucumber 2.13.4 → 2.13.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d8e51c721ebb6ab689c0b0a4d0403f0985ce78dcfed3c7636ab373d6a022d01
-  data.tar.gz: 38e5d9e0f65921e12e16b097c6cbbbe7525f7ced18d64f9d107f05be3eb309e0
+  metadata.gz: eec16fa4b2661ebc292fcfe4822f3c53c5af7d66985269696ea79a7fde7ebc30
+  data.tar.gz: 8081549604e82be68e300179457fe6721e79f2eef605c3b848b9808938458f24
 SHA512:
-  metadata.gz: dcce7431269029e6193e1465c1b42daaed2cb0890034654a0310fc7e63dbcd6000f30c6e2782ed4d86828858de50a665b80e15423a566a4fa7194782ac9548e5
-  data.tar.gz: 0a66d830ccb8db25ac1a843ee18ca286ec2a951f671064d100d7deab67d7b1cf97615ab5caec171018ebe1c6603d7b33bc11c318ace76eb5bc0a80f408a4d5cd
+  metadata.gz: 4768b05e93476e415640b22bf27463da0e4231bd2176d461046e2994fa43f88433a0d5aa488956c52666f26a002059c447048983e7ea36325cfd485da8afe65f
+  data.tar.gz: 5570eda7e1d86330723f363778542a3a90b93d328a7d413e632037e5ad7556909ac0ff996ea48bdb8b7ebd054d542a04221ac56c8c31f49503b0378ca736aa46

data/README.md

@@ -1,44 +1,58 @@
 # Allure Cucumber Adaptor
+
 [![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](https://www.rubydoc.info/gems/allure-cucumber)
 
 This repository contains Allure adaptor for [Cucumber](http://cukes.info/) framework.
 
+## Cucumber versions
+
+allure-cucumber versions <= 2.13.4 support only cucumber 3 and lower\
+allure-cucumber versions >= 2.13.5 only support cucumber 4 and are not backwards compatible with cucumber 3 and lower
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'allure-cucumber'
+gem "allure-cucumber"
 ```
 
 And then execute:
 
 ```bash
-  $ bundle
+  bundle
 ```
 
 Or install it yourself as:
 
 ```bash
-  $ gem install allure-cucumber
+  gem install allure-cucumber
+```
+
+Require in "support/env.rb":
+
+```ruby
+require "allure-cucumber"
 ```
 
 ## Configuration
 
-Common allure configuration is set via `Allure.configure` method. To change id, add the following in `features/support/env.rb` file:
+Common allure configuration is set via `AllureCucumber.configure` method. To change it, add the following in `features/support/env.rb` file:
 
 ```ruby
-Allure.configure do |c|
-  c.results_directory = "/whatever/you/like"
-  c.clean_results_directory = true
-  c.logging_level = Logger::INFO
+require "allure-cucumber"
+
+AllureCucumber.configure do |config|
+  config.results_directory = "/whatever/you/like"
+  config.clean_results_directory = true
+  config.logging_level = Logger::INFO
   # these are used for creating links to bugs or test cases where {} is replaced with keys of relevant items
-  c.link_tms_pattern = "http://www.jira.com/browse/{}"
-  c.link_issue_pattern = "http://www.jira.com/browse/{}"
+  config.link_tms_pattern = "http://www.jira.com/browse/{}"
+  config.link_issue_pattern = "http://www.jira.com/browse/{}"
 end
 ```
 
-By default, allure-cucumber will analyze your cucumber tags looking for Test Management, Issue Management, and Severity hooks. Links to TMS and ISSUE and test severity will be displayed in the report. By default these prefixes are used:
+By default, allure-cucumber will analyze your cucumber tags looking for Test Management, Issue Management, and Severity tag. Links to TMS and ISSUE and test severity will be displayed in the report. By default these prefixes are used:
 
 ```ruby
     DEFAULT_TMS_PREFIX      = 'TMS:'
@@ -58,10 +72,10 @@ Example:
 You can configure these prefixes as well as tms and issue tracker urls like this:
 
 ```ruby
-AllureCucumber.configure do |c|
-  c.tms_prefix      = 'HIPTEST--'
-  c.issue_prefix    = 'JIRA++'
-  c.severity_prefix = 'URGENCY:'
+AllureCucumber.configure do |config|
+  config.tms_prefix      = 'HIPTEST--'
+  config.issue_prefix    = 'JIRA++'
+  config.severity_prefix = 'URGENCY:'
 end
 ```
 
@@ -78,12 +92,6 @@ Additional special tags exists for setting status detail of test scenarios, allu
 
 ## Usage
 
-Put the following in your `features/support/env.rb` file:
-
-```ruby
-require 'allure-cucumber'
-```
-
 Use `--format AllureCucumber::CucumberFormatter --out where/you-want-results` while running cucumber or add it to `cucumber.yml`. Note that cucumber `--out` option overrides `results_directory` set via `Allure.configure` method.
 
 You can also manually attach screenshots and links to test steps and test cases by interacting with allure lifecycle directly. For more info check out `allure-ruby-commons`

data/lib/allure-cucumber.rb

@@ -3,8 +3,8 @@
 
 require "allure-ruby-commons"
 
-require "allure_cucumber/formatter"
 require "allure_cucumber/config"
+require "allure_cucumber/formatter"
 
 # Main allure-cucumber module providing configuration methods
 module AllureCucumber
@@ -12,7 +12,7 @@ module AllureCucumber
     # Get allure cucumber configuration
     # @return [Allure::CucumberConfig]
     def configuration
-      CucumberConfig
+      CucumberConfig.instance
     end
 
     # Set allure configuration
@@ -20,7 +20,7 @@ module AllureCucumber
     # @yieldreturn [void]
     # @return [void]
     def configure
-      yield(CucumberConfig)
+      yield(configuration)
     end
   end
 end

data/lib/allure_cucumber/config.rb

@@ -1,32 +1,52 @@
 # frozen_string_literal: true
 
+require "singleton"
+require "forwardable"
+
 module AllureCucumber
   # Allure cucumber configuration
-  class CucumberConfig
-    class << self
-      # @return [String] default tms tag prefix
-      DEFAULT_TMS_PREFIX = "TMS:"
-      # @return [String] default issue tag prefix
-      DEFAULT_ISSUE_PREFIX = "ISSUE:"
-      # @return [String] default severity tag prefix
-      DEFAULT_SEVERITY_PREFIX = "SEVERITY:"
-
-      attr_writer :tms_prefix, :issue_prefix, :severity_prefix
-
-      # @return [String]
-      def tms_prefix
-        @tms_prefix || DEFAULT_TMS_PREFIX
-      end
-
-      # @return [String]
-      def issue_prefix
-        @issue_prefix || DEFAULT_ISSUE_PREFIX
-      end
-
-      # @return [String]
-      def severity_prefix
-        @severity_prefix || DEFAULT_SEVERITY_PREFIX
-      end
+  class CucumberConfig < Allure::Config
+    include Singleton
+    extend Forwardable
+
+    # @return [String] default tms tag prefix
+    DEFAULT_TMS_PREFIX = "TMS:"
+    # @return [String] default issue tag prefix
+    DEFAULT_ISSUE_PREFIX = "ISSUE:"
+    # @return [String] default severity tag prefix
+    DEFAULT_SEVERITY_PREFIX = "SEVERITY:"
+
+    def_delegators :@allure_config,
+      :clean_results_directory,
+      :clean_results_directory=,
+      :link_issue_pattern,
+      :link_issue_pattern=,
+      :link_tms_pattern,
+      :link_tms_pattern=,
+      :logging_level,
+      :logging_level=,
+      :results_directory,
+      :results_directory=
+
+    attr_writer :tms_prefix, :issue_prefix, :severity_prefix
+
+    def initialize
+      @allure_config = Allure.configuration
+    end
+
+    # @return [String]
+    def tms_prefix
+      @tms_prefix || DEFAULT_TMS_PREFIX
+    end
+
+    # @return [String]
+    def issue_prefix
+      @issue_prefix || DEFAULT_ISSUE_PREFIX
+    end
+
+    # @return [String]
+    def severity_prefix
+      @severity_prefix || DEFAULT_SEVERITY_PREFIX
     end
   end
 end

data/lib/allure_cucumber/formatter.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "cucumber_model"
+require "cucumber/core"
+
+require_relative "models/cucumber_model"
 
 module AllureCucumber
   # Main formatter class. Translates cucumber event to allure lifecycle
   class CucumberFormatter
-    include AllureCucumberModel
-
     # @return [Hash] hook handler methods
     HOOK_HANDLERS = {
       "Before hook" => :start_prepare_fixture,
@@ -25,6 +25,8 @@ module AllureCucumber
         c.results_directory = config.out_stream if config.out_stream.is_a?(String)
       end
 
+      @cucumber_model = AllureCucumberModel.new(config)
+
       config.on_event(:test_run_started, &method(:on_test_run_started))
       config.on_event(:test_case_started, &method(:on_test_case_started))
       config.on_event(:test_step_started, &method(:on_test_step_started))
@@ -33,48 +35,46 @@ module AllureCucumber
     end
 
     # Clean test result directory before starting run
-    # @param [Cucumber::Events::TestRunStarted<Type>] _event
+    # @param [Cucumber::Events::TestRunStarted] _event
     # @return [void]
     def on_test_run_started(_event)
       lifecycle.clean_results_dir
     end
 
     # Handle test case started event
-    # @param [Cucumber::Core::Events::TestCaseStarted] event
+    # @param [Cucumber::Events::TestCaseStarted] event
     # @return [void]
     def on_test_case_started(event)
       lifecycle.start_test_container(Allure::TestResultContainer.new(name: event.test_case.name))
-      lifecycle.start_test_case(test_result(event.test_case))
+      lifecycle.start_test_case(cucumber_model.test_result(event.test_case))
     end
 
     # Handle test step started event
-    # @param [Cucumber::Core::Events::TestStepStarted] event
+    # @param [Cucumber::Events::TestStepStarted] event
     # @return [void]
     def on_test_step_started(event)
-      hook?(event.test_step) ? handle_hook_started(event.test_step) : handle_step_started(event.test_step)
+      event.test_step.hook? ? handle_hook_started(event.test_step) : handle_step_started(event.test_step)
     end
 
     # Handle test step finished event
-    # @param [Cucumber::Core::Events::TestStepFinished] event
+    # @param [Cucumber::Events::TestStepFinished] event
     # @return [void]
     def on_test_step_finished(event)
-      return if prepare_world_hook?(event.test_step)
-
       update_block = proc do |step|
         step.stage = Allure::Stage::FINISHED
         step.status = ALLURE_STATUS.fetch(event.result.to_sym, Allure::Status::BROKEN)
       end
-      step_type = hook?(event.test_step) ? "fixture" : "test_step"
+      step_type = event.test_step.hook? ? "fixture" : "test_step"
 
       lifecycle.public_send("update_#{step_type}", &update_block)
       lifecycle.public_send("stop_#{step_type}")
     end
 
     # Handle test case finished event
-    # @param [Cucumber::Core::Events::TestCaseFinished] event
+    # @param [Cucumber::Events::TestCaseFinished] event
     # @return [void]
     def on_test_case_finished(event)
-      failure_details = failure_details(event.result)
+      failure_details = cucumber_model.failure_details(event.result)
       status = ALLURE_STATUS.fetch(event.result.to_sym, Allure::Status::BROKEN)
       lifecycle.update_test_case do |test_case|
         test_case.stage = Allure::Stage::FINISHED
@@ -89,30 +89,26 @@ module AllureCucumber
 
     private
 
-    # @param [Cucumber::Core::Test::Step] test_step <description>
-    # @return [Boolean]
-    def hook?(test_step)
-      HOOK_HANDLERS.key?(test_step.text)
-    end
+    attr_accessor :cucumber_model
 
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [Boolean]
-    def prepare_world_hook?(test_step)
-      hook?(test_step) && test_step.inspect.include?("prepare_world.rb")
+    # Get thread specific lifecycle
+    # @return [Allure::AllureLifecycle]
+    def lifecycle
+      Allure.lifecycle
     end
 
     # @param [Cucumber::Core::Test::Step] test_step
     # @return [void]
     def handle_step_started(test_step)
-      lifecycle.start_test_step(step_result(test_step))
+      step = cucumber_model.step_result(test_step)
+      lifecycle.start_test_step(step[:allure_step])
+      step[:attachments].each { |att| lifecycle.write_attachment(att[:source], att[:allure_attachment]) }
     end
 
-    # @param [Cucumber::Core::Test::Step] test_step
+    # @param [Cucumber::Core::Test::HookStep] hook_step
     # @return [void]
-    def handle_hook_started(test_step)
-      return if prepare_world_hook?(test_step)
-
-      lifecycle.public_send(HOOK_HANDLERS[test_step.text], fixture_result(test_step))
+    def handle_hook_started(hook_step)
+      lifecycle.public_send(HOOK_HANDLERS[hook_step.text], cucumber_model.fixture_result(hook_step))
     end
   end
 end

data/lib/allure_cucumber/models/cucumber_model.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "csv"
+require "cucumber/core"
+require "cucumber/formatter/ast_lookup"
+
+require_relative "scenario"
+require_relative "step"
+require_relative "tag_parser"
+
+module AllureCucumber
+  # Support class for transforming cucumber test entities in to allure model entities
+  class AllureCucumberModel
+    include TagParser
+
+    # @param [Cucumber::Configuration] config
+    def initialize(config)
+      @ast_lookup = Cucumber::Formatter::AstLookup.new(config)
+    end
+
+    # Convert to allure test result
+    # @param [Cucumber::Core::Test::Case] test_case
+    # @return [Allure::TestResult]
+    def test_result(test_case)
+      scenario = Scenario.new(test_case, ast_lookup)
+
+      Allure::TestResult.new(
+        name: scenario.name,
+        description: scenario.description,
+        description_html: scenario.description,
+        history_id: scenario.id,
+        full_name: "#{scenario.feature_name}: #{scenario.name}",
+        labels: labels(scenario),
+        links: links(scenario),
+        parameters: parameters(scenario),
+        status_details: Allure::StatusDetails.new(**status_detail_tags(scenario.tags)),
+      )
+    end
+
+    # Convert to allure step result
+    # @param [Cucumber::Core::Test::Step] test_step
+    # @return [Hash]
+    def step_result(test_step)
+      step = Step.new(ast_lookup.step_source(test_step))
+      attachments = step_attachments(step)
+      allure_step = Allure::StepResult.new(
+        name: step.name,
+        attachments: attachments.map { |att| att[:allure_attachment] },
+      )
+
+      { allure_step: allure_step, attachments: attachments }
+    end
+
+    # Convert to allure step result
+    # @param [Cucumber::Core::Test::HookStep] hook_step
+    # @return [Allure::StepResult]
+    def fixture_result(hook_step)
+      Allure::FixtureResult.new(name: hook_step.location.to_s.split("/").last)
+    end
+
+    # Get failure details
+    # @param [Cucumber::Core::Test::Result] result
+    # @return [Hash<Symbol, String>]
+    def failure_details(result)
+      return { message: result.exception.message, trace: result.exception.backtrace.join("\n") } if result.failed?
+      return { message: result.message, trace: result.backtrace.join("\n") } if result.undefined?
+
+      {}
+    end
+
+    private
+
+    attr_reader :ast_lookup, :lifecycle
+
+    # @param [Scenario] scenario
+    # @return [Array<Allure::Label>]
+    def labels(scenario)
+      labels = []
+      labels << Allure::ResultUtils.framework_label("cucumber")
+      labels << Allure::ResultUtils.feature_label(scenario.feature_name)
+      labels << Allure::ResultUtils.package_label(scenario.feature_folder)
+      labels << Allure::ResultUtils.suite_label(scenario.feature_name)
+      labels << Allure::ResultUtils.story_label(scenario.name)
+      labels << Allure::ResultUtils.test_class_label(scenario.feature_file_name)
+      unless scenario.tags.empty?
+        labels.push(*tag_labels(scenario.tags))
+        labels << severity(scenario.tags)
+      end
+
+      labels
+    end
+
+    # @param [Cucumber::Core::Test::Case] test_case
+    # @return [Array<Allure::Link>]
+    def links(test_case)
+      tms_links(test_case.tags) + issue_links(test_case.tags)
+    end
+
+    # @param [AllureCucumber::Scenario] scenario
+    # @return [Array<Allure::Parameter>]
+    def parameters(scenario)
+      scenario.examples.map { |k, v| Allure::Parameter.new(k, v) }
+    end
+
+    # @param [Step] step
+    # @return [Array<Allure::Attachment>]
+    def step_attachments(step)
+      [data_table_attachment(step), docstring_attachment(step)].compact
+    end
+
+    # @param [Step] step
+    # @return [Allure::Attachment]
+    def data_table_attachment(step)
+      return unless step.data_table
+
+      attachment = Allure::ResultUtils.prepare_attachment("data-table", Allure::ContentType::CSV)
+      csv = step.data_table.rows.each_with_object([]) { |row, arr| arr.push(row.cells.map(&:value).to_csv) }.join("")
+      { source: csv, allure_attachment: attachment }
+    end
+
+    # @param [Step] step
+    # @return [String]
+    def docstring_attachment(step)
+      return unless step.doc_string
+
+      attachment = Allure::ResultUtils.prepare_attachment("docstring", Allure::ContentType::TXT)
+      { source: step.doc_string.content, allure_attachment: attachment }
+    end
+  end
+end

data/lib/allure_cucumber/models/scenario.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module AllureCucumber
+  # Cucumber scenario wrapper class
+  class Scenario
+    # @param [Cucumber::Core::Test::Case] test_case
+    # @param [Cucumber::Formatter::AstLookup] ast_lookup
+    def initialize(test_case, ast_lookup)
+      @test_case = test_case
+      @feature = ast_lookup.gherkin_document(test_case.location.file).feature
+      @scenario_source = ast_lookup.scenario_source(test_case)
+    end
+
+    # Unique scenario id
+    # @return [String]
+    def id
+      @id ||= Digest::MD5.hexdigest(test_case.inspect)
+    end
+
+    # Feature name scenario belongs to
+    # @return [String]
+    def feature_name
+      @feature_name ||= feature.name
+    end
+
+    # Scenario name
+    # @return [String]
+    def name
+      @name ||= scenario_outline? ? "#{scenario.name}, #{example_row}" : scenario.name
+    end
+
+    # Scenario description or it's location
+    # @return [String]
+    def description
+      @description ||= begin
+        scenario.description.empty? ? "Location - #{test_case.location}" : scenario.description.strip
+      end
+    end
+
+    # Scenario outline row parameters
+    # @return [Hash<String, String>]
+    def examples
+      @examples ||= scenario_outline? ? outline_parameters : {}
+    end
+
+    # Scenario tags
+    # @return [Array<String>]
+    def tags
+      @tags ||= test_case.tags.map(&:name)
+    end
+
+    # Feature file name
+    # @return [String]
+    def feature_file_name
+      @feature_file_name ||= test_case.location.file.split("/").last.gsub(".feature", "")
+    end
+
+    # Feature folder
+    # @return [String]
+    def feature_folder
+      @feature_folder ||= test_case.location.file.split("/")[-2]
+    end
+
+    private
+
+    attr_reader :test_case, :scenario_source, :feature
+
+    # Is scenario outline
+    # @return [Boolean]
+    def scenario_outline?
+      scenario_source.type == :ScenarioOutline
+    end
+
+    # Cucumber scenario object
+    # @return [
+    #   Cucumber::Messages::GherkinDocument::Feature::Scenario,
+    #   Cucumber::Messages::GherkinDocument::Feature::ScenarioOutline
+    # ]
+    def scenario
+      @scenario ||= scenario_outline? ? scenario_source.scenario_outline : scenario_source.scenario
+    end
+
+    # Scenario outline example row
+    # @return [String]
+    def example_row
+      @example_row ||= begin
+        "Examples (##{scenario_source.examples.table_body.index { |row| row.id == scenario_source.row.id } + 1})"
+      end
+    end
+
+    # Scenario outline row parameters
+    # @return [Hash<String, String>]
+    def outline_parameters
+      @outline_parameters ||= begin
+        names = scenario_source.examples.table_header.cells.map(&:value)
+        values = scenario_source.row.cells.map(&:value)
+        names.zip(values).to_h
+      end
+    end
+  end
+end

data/lib/allure_cucumber/models/step.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AllureCucumber
+  # Cucumber step wrapper class
+  class Step
+    # @param [Cucumber::Formatter::AstLookup::StepSource] step_source
+    def initialize(step_source)
+      @step = step_source.step
+    end
+
+    # Step name
+    # @return [String]
+    def name
+      @name ||= "#{step.keyword}#{step.text}"
+    end
+
+    # Step data table
+    # @return [Cucumber::Messages::GherkinDocument::Feature::Step::DataTable]
+    def data_table
+      @data_table ||= step.data_table
+    end
+
+    # Step docstring
+    # @return [String]
+    def doc_string
+      @doc_string ||= step.doc_string
+    end
+
+    private
+
+    attr_reader :step
+  end
+end

data/lib/allure_cucumber/{tag_parser.rb → models/tag_parser.rb}

@@ -1,46 +1,44 @@
 # frozen_string_literal: true
 
-require_relative "config"
-
 module AllureCucumber
   # Cucumber tag parser helper methods
   module TagParser
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @return [Array<Allure::Label>]
     def tag_labels(tags)
       tags
-        .reject { |tag| reserved?(tag.name) }
-        .map { |tag| Allure::ResultUtils.tag_label(tag.name.delete_prefix("@")) }
+        .reject { |tag| reserved?(tag) }
+        .map { |tag| Allure::ResultUtils.tag_label(tag.delete_prefix("@")) }
     end
 
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @return [Array<Allure::Link>]
     def tms_links(tags)
-      return [] unless Allure::Config.link_tms_pattern
+      return [] unless AllureCucumber.configuration.link_tms_pattern
 
       matching_links(tags, :tms)
     end
 
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @return [Array<Allure::Link>]
     def issue_links(tags)
-      return [] unless Allure::Config.link_issue_pattern
+      return [] unless AllureCucumber.configuration.link_issue_pattern
 
       matching_links(tags, :issue)
     end
 
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @return [Allure::Label]
     def severity(tags)
       severity_pattern = reserved_patterns[:severity]
       severity = tags
-        .detect { |tag| tag.name.match?(severity_pattern) }&.name
+        .detect { |tag| tag.match?(severity_pattern) }
         &.match(severity_pattern)&.[](:severity) || "normal"
 
       Allure::ResultUtils.severity_label(severity)
     end
 
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @return [Hash<Symbol, Boolean>]
     def status_detail_tags(tags)
       {
@@ -52,22 +50,22 @@ module AllureCucumber
 
     private
 
-    # @param [Array<Cucumber::Core::Ast::Tag>] tags
+    # @param [Array<String>] tags
     # @param [Symbol] type
     # @return [Array<Allure::Link>]
     def matching_links(tags, type)
       pattern = reserved_patterns[type]
       tags
-        .select { |tag| tag.name.match?(pattern) }
-        .map { |tag| tag.name.match(pattern) { |match| Allure::ResultUtils.public_send("#{type}_link", match[type]) } }
+        .select { |tag| tag.match?(pattern) }
+        .map { |tag| tag.match(pattern) { |match| Allure::ResultUtils.public_send("#{type}_link", match[type]) } }
     end
 
     # @return [Hash<Symbol, Regexp>]
     def reserved_patterns
       @reserved_patterns ||= {
-        tms: /@#{CucumberConfig.tms_prefix}(?<tms>\S+)/,
-        issue: /@#{CucumberConfig.issue_prefix}(?<issue>\S+)/,
-        severity: /@#{CucumberConfig.severity_prefix}(?<severity>\S+)/,
+        tms: /@#{AllureCucumber.configuration.tms_prefix}(?<tms>\S+)/,
+        issue: /@#{AllureCucumber.configuration.issue_prefix}(?<issue>\S+)/,
+        severity: /@#{AllureCucumber.configuration.severity_prefix}(?<severity>\S+)/,
         flaky: /@flaky/,
         muted: /@muted/,
         known: /@known/,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allure-cucumber
 version: !ruby/object:Gem::Version
-  version: 2.13.4
+  version: 2.13.6.1
 platform: ruby
 authors:
 - Andrejs Cunskis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-25 00:00:00.000000000 Z
+date: 2020-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allure-ruby-commons
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.13.4
+        version: 2.13.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.13.4
+        version: 2.13.6.1
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 4.0.0
 description: Cucumber adaptor to generate rich allure test reports
 email: andrejs.cunskis@gmail.com
 executables: []
@@ -46,11 +46,12 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/allure-cucumber.rb
-- lib/allure_cucumber/ast_transformer.rb
 - lib/allure_cucumber/config.rb
-- lib/allure_cucumber/cucumber_model.rb
 - lib/allure_cucumber/formatter.rb
-- lib/allure_cucumber/tag_parser.rb
+- lib/allure_cucumber/models/cucumber_model.rb
+- lib/allure_cucumber/models/scenario.rb
+- lib/allure_cucumber/models/step.rb
+- lib/allure_cucumber/models/tag_parser.rb
 homepage: https://github.com/allure-framework/allure-ruby
 licenses:
 - Apache-2.0

data/lib/allure_cucumber/ast_transformer.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module AllureCucumber
-  # Cucumber::Core::Ast is removed in cucumber-core 4.0 version.
-  # This will have to be updated accordingly, once stable version rolls out
-  module AstTransformer
-    # Get scenario object
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [Cucumber::Core::Ast::Scenario, Cucumber::Core::Ast::ScenarioOutline]
-    def scenario(test_case)
-      test_case.source.detect do |it|
-        it.is_a?(Cucumber::Core::Ast::Scenario) || it.is_a?(Cucumber::Core::Ast::ScenarioOutline)
-      end
-    end
-
-    # Get step object
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [Cucumber::Core::Ast::Step]
-    def step(test_step)
-      test_step.source.detect { |it| it.is_a?(Cucumber::Core::Ast::Step) }
-    end
-
-    # Get scenario outline example row
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [Cucumber::Core::Ast::ExamplesTable::Row]
-    def example_row(test_case)
-      test_case.source.detect { |it| it.is_a?(Cucumber::Core::Ast::ExamplesTable::Row) }
-    end
-
-    # Get step multiline argument
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [Cucumber::Core::Ast::DataTable, String]
-    def multiline_arg(test_step)
-      multiline_arg = step(test_step).multiline_arg
-      return if multiline_arg.is_a?(Cucumber::Core::Ast::EmptyMultilineArgument)
-
-      multiline_arg
-    end
-  end
-end

data/lib/allure_cucumber/cucumber_model.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "cucumber"
-require "cucumber/core"
-require "digest"
-require "csv"
-
-require_relative "ast_transformer"
-require_relative "tag_parser"
-
-module AllureCucumber
-  # Support class for transforming cucumber test entities in to allure model entities
-  module AllureCucumberModel
-    include AstTransformer
-    include TagParser
-
-    # Convert to allure test result
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [TestResult]
-    def test_result(test_case)
-      Allure::TestResult.new(
-        name: test_case.name,
-        description: description(test_case),
-        description_html: description(test_case),
-        history_id: Digest::MD5.hexdigest(test_case.inspect),
-        full_name: "#{test_case.feature.name}: #{test_case.name}",
-        labels: labels(test_case),
-        links: links(test_case),
-        parameters: parameters(test_case) || [],
-        status_details: Allure::StatusDetails.new(**status_detail_tags(test_case.tags.map(&:name))),
-      )
-    end
-
-    # Convert to allure step result
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [StepResult]
-    def step_result(test_step)
-      Allure::StepResult.new(
-        name: "#{step(test_step).keyword}#{test_step.text}",
-        attachments: [multiline_arg_attachment(test_step)].compact,
-      )
-    end
-
-    # Convert to allure step result
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [StepResult]
-    def fixture_result(test_step)
-      location = test_step.location.to_s.split("/").last
-      Allure::FixtureResult.new(name: location)
-    end
-
-    # Get failure details
-    # @param [Cucumber::Core::Test::Result] result <description>
-    # @return [Hash<Symbol, String>]
-    def failure_details(result)
-      return { message: result.exception.message, trace: result.exception.backtrace.join("\n") } if result.failed?
-      return { message: result.message, trace: result.backtrace.join("\n") } if result.undefined?
-
-      {}
-    end
-
-    # Get thread specific lifecycle
-    # @return [Allure::AllureLifecycle]
-    def lifecycle
-      Allure.lifecycle
-    end
-
-    private
-
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [Array<Allure::Label>]
-    def labels(test_case)
-      labels = []
-      labels << Allure::ResultUtils.framework_label("cucumber")
-      labels << Allure::ResultUtils.feature_label(test_case.feature.name)
-      labels << Allure::ResultUtils.package_label(test_case.feature.name)
-      labels << Allure::ResultUtils.suite_label(test_case.feature.name)
-      labels << Allure::ResultUtils.story_label(test_case.name)
-      labels << Allure::ResultUtils.test_class_label(test_case.name)
-      unless test_case.tags.empty?
-        labels.push(*tag_labels(test_case.tags))
-        labels << severity(test_case.tags)
-      end
-
-      labels
-    end
-
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [Array<Allure::Link>]
-    def links(test_case)
-      return [] unless test_case.tags
-
-      tms_links(test_case.tags) + issue_links(test_case.tags)
-    end
-
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [Array<Allure::Parameter>]
-    def parameters(test_case)
-      example_row(test_case)&.values&.map { |value| Allure::Parameter.new("argument", value) }
-    end
-
-    # @param [Cucumber::Core::Test::Case] test_case
-    # @return [String]
-    def description(test_case)
-      scenario = scenario(test_case)
-      scenario.description.empty? ? "Location - #{scenario.file_colon_line}" : scenario.description.strip
-    end
-
-    # @param [Cucumber::Core::Test::Step] test_step
-    # @return [Allure::Attachment]
-    def multiline_arg_attachment(test_step)
-      arg = multiline_arg(test_step)
-      return unless arg
-
-      arg.data_table? ? data_table_attachment(arg) : docstring_attachment(arg)
-    end
-
-    # @param [Cucumber::Core::Ast::DataTable] multiline_arg
-    # @return [Allure::Attachment]
-    def data_table_attachment(multiline_arg)
-      attachment = lifecycle.prepare_attachment("data-table", Allure::ContentType::CSV)
-      csv = multiline_arg.raw.each_with_object([]) { |row, arr| arr.push(row.to_csv) }.join("")
-      lifecycle.write_attachment(csv, attachment)
-      attachment
-    end
-
-    # @param [String] multiline_arg
-    # @return [String]
-    def docstring_attachment(multiline_arg)
-      attachment = lifecycle.prepare_attachment("docstring", Allure::ContentType::TXT)
-      lifecycle.write_attachment(multiline_arg.content, attachment)
-      attachment
-    end
-  end
-end