allure-cucumber 2.13.4 → 2.13.5.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d8e51c721ebb6ab689c0b0a4d0403f0985ce78dcfed3c7636ab373d6a022d01
-  data.tar.gz: 38e5d9e0f65921e12e16b097c6cbbbe7525f7ced18d64f9d107f05be3eb309e0
+  metadata.gz: 660dd75c5884bb993804ca888ccb2babc2e997bf38a3c4c12105dfffe9948394
+  data.tar.gz: 06fd91978393b639e8d92b6b87b7ce752778d254a5a50caf19565d34fefd9f31
 SHA512:
-  metadata.gz: dcce7431269029e6193e1465c1b42daaed2cb0890034654a0310fc7e63dbcd6000f30c6e2782ed4d86828858de50a665b80e15423a566a4fa7194782ac9548e5
-  data.tar.gz: 0a66d830ccb8db25ac1a843ee18ca286ec2a951f671064d100d7deab67d7b1cf97615ab5caec171018ebe1c6603d7b33bc11c318ace76eb5bc0a80f408a4d5cd
+  metadata.gz: dec76bf5806c56bfaa484797b2e27e794dae083ab48cbd741e654cd72adf9e19e280723be0d96c3a6b218c826dc4caa757883e22427eb81273ea39f1bca561b6
+  data.tar.gz: 2fdc18e522ead6101e5fab6d73e973861bc576167a778b268cc3eaf32e0e45a9866df8f93860705c09c33cd2dfbe04694bb6258508414578f32fa193e40badd0

data/README.md

@@ -1,4 +1,5 @@
 # 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.
@@ -14,15 +15,20 @@ gem 'allure-cucumber'
 And then execute:
 
 ```bash
-  $ bundle
+  bundle
 ```
 
 Or install it yourself as:
 
 ```bash
-  $ gem install allure-cucumber
+  gem install allure-cucumber
 ```
 
+## 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
+
 ## Configuration
 
 Common allure configuration is set via `Allure.configure` method. To change id, add the following in `features/support/env.rb` file:

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

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,19 +1,17 @@
 # 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
@@ -21,7 +19,7 @@ module AllureCucumber
       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
@@ -29,18 +27,18 @@ module AllureCucumber
       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,14 +50,14 @@ 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>]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allure-cucumber
 version: !ruby/object:Gem::Version
-  version: 2.13.4
+  version: 2.13.5.rc.1
 platform: ruby
 authors:
 - Andrejs Cunskis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-25 00:00:00.000000000 Z
+date: 2020-03-28 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.5.rc.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.13.4
+        version: 2.13.5.rc.1
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 4.0.0.rc5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: 4.0.0.rc5
 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
@@ -71,9 +72,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
 signing_key: 

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