allure-cucumber 0.6.1 → 2.10.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fe8dfcc9914bde86e27fe7821d7b63d9c20fa287
-  data.tar.gz: a3c993bd799f18da9987b9b7dcaab15d1975cc90
+SHA256:
+  metadata.gz: 9bc852a2f1482e456bd23540b32a67d4146b9d6b8590f27d6da50adbf016a029
+  data.tar.gz: 4b4161e222b30491a723de00233e6a7c236085c1c06d8b74244208ff45a6f7b1
 SHA512:
-  metadata.gz: 535d1c8ec1f59333ce31cef0d0502975fc79d6986a06e15c5db0da959c9e930d51bd4f8cc6121d7b4df7712b1f77dcb208d30373d238ad560f3769cbc27b90dc
-  data.tar.gz: ce4ed843506590f910661749399bc45e705cf0cdb5f3e44e97ea9c30601952c1cc44811d9351aa6e6740eef7eca5f4b171f8d5710233341542bd7ff40ff4142d
+  metadata.gz: c5ca4b1baa03fd8ddcb77b1f884df7b2231437f15bab7ac4d1905fd74bb43b5d33cc0298b1a788377f1c5bf28774f274cb251b87818bc77cb11af38abc441160
+  data.tar.gz: '07806178de6bc0d58b64d41eb3297282589546a508fe92e36d80b3f0b0cbf4cbde35fa1822356db128e0c52154e70b917b5367481a8579ece9c41f5b18b6f2a2'

data/README.md

@@ -21,28 +21,20 @@ $ gem install allure-cucumber
 
 ## Configuration
 
-By default, Allure XML files are stored in `gen/allure-results`. To change this add the following in `features/support/env.rb` file:
+By default, Allure json files are stored in `reports/allure-results`. To change this add the following in `features/support/env.rb` file:
 
 ```ruby
-AllureCucumber.configure do |c|
-   c.output_dir = "/output/dir"
+Allure.configure do |c|
+   c.results_directory = "/output/dir"
 end
 ```
 
-By default, the Allure XML files from earlier runs are deleted at the start of new run. This can be disabled by:
-
-```ruby
-AllureCucumber.configure do |c|
-  c.clean_dir  = false
-end
-```
-
-By default, allure-cucumber will analyze your cucumber tags looking for Test Management, Issue Management, and Severity hooks. These hooks will be displayed in the generated allure report (see allure-core for further info). 
+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:
 
 ```ruby    
-    DEFAULT_TMS_PREFIX      = '@TMS:'
-    DEFAULT_ISSUE_PREFIX    = '@ISSUE:'
-    DEFAULT_SEVERITY_PREFIX = '@SEVERITY:'
+    DEFAULT_TMS_PREFIX      = 'TMS:'
+    DEFAULT_ISSUE_PREFIX    = 'ISSUE:'
+    DEFAULT_SEVERITY_PREFIX = 'SEVERITY:'
 ```
 
 Example: 
@@ -53,14 +45,15 @@ Example:
     Then exactly (1) [validation_error] should be visible
 ```    
 
-You can configure what allure-cucumber looks for by making the following changes
+You can configure these prefixes as well as tms and issue tracker urls like this:
 
 ```ruby
-AllureCucumber.configure do |c|
-  c.clean_dir  = false
-  c.tms_prefix      = '@HIPTEST--'
-  c.issue_prefix    = '@JIRA++'
-  c.severity_prefix = '@URGENCY:'
+Allure.configure do |c|
+  c.link_tms_pattern = "http://www.hiptest.com/tms/{}"
+  c.link_issue_pattern = "http://www.jira.com/browse/{}"
+  c.tms_prefix      = 'HIPTEST--'
+  c.issue_prefix    = 'JIRA++'
+  c.severity_prefix = 'URGENCY:'
 end
 ```
 
@@ -72,6 +65,8 @@ Example:
     Then exactly (1) [validation_error] should be visible
 ```    
 
+Additional special tags exists for setting status detail of test scenarios, allure will pick up following tags: `@flaky`, `@known` and `@muted`
+
 ## Usage
 
 Put the following in your `features/support/env.rb` file:
@@ -80,17 +75,18 @@ Put the following in your `features/support/env.rb` file:
 require 'allure-cucumber'
 ```
 
-Use `--format AllureCucumber::Formatter --out where/you-want-results` while running cucumber or add it to `cucumber.yml`
+Use `--format Allure::CucumberFormatter --out where/you-want-results` while running cucumber or add it to `cucumber.yml`
 
-You can also [attach screenshots](https://github.com/allure-framework/allure-core/wiki/Glossary#attachment), logs or test data to [steps](https://github.com/allure-framework/allure-core/wiki/Glossary#test-step).
+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`
 
 ```ruby
 # file: features/support/env.rb
 
-include AllureCucumber::DSL
+require "allure-cucumber"
 
-attach_file(title, file)
+Allure.add_attachment(name: "attachment", source: "Some string", type: Allure::ContentType::TXT, test_case: true)
+Allure.add_link("Custom Url", "http://www.github.com")
 ```
 
 ## How to generate report
-This adapter only generates XML files containing information about tests. See [wiki section](https://github.com/allure-framework/allure-core/wiki#generating-report) on how to generate report.
+This adaptor only generates json files containing information about tests. See [wiki section](https://docs.qameta.io/allure/#_reporting) on how to generate report.

data/lib/allure-cucumber.rb

@@ -1,52 +1,26 @@
-require 'allure-ruby-adaptor-api'
-require 'allure-cucumber/version'
-require 'allure-cucumber/feature_tracker'
-require 'allure-cucumber/dsl'
-require 'allure-cucumber/formatter'
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
 
-module AllureCucumber
+require "allure-ruby-commons"
 
-  module Config
-    class << self
-
-      attr_accessor :output_dir, :clean_dir, :tms_prefix, :issue_prefix, :severity_prefix
-
-      DEFAULT_OUTPUT_DIR      = 'gen/allure-results'
-      DEFAULT_TMS_PREFIX      = '@TMS:'
-      DEFAULT_ISSUE_PREFIX    = '@ISSUE:'
-      DEFAULT_SEVERITY_PREFIX = '@SEVERITY:'
-
-      def output_dir
-        @output_dir || DEFAULT_OUTPUT_DIR
-      end
-
-      def output_dir=(output_dir)
-        AllureRubyAdaptorApi::Config.output_dir = output_dir
-        @output_dir = output_dir
-      end
-
-      def tms_prefix
-        @tms_prefix || DEFAULT_TMS_PREFIX
-      end
-
-      def issue_prefix
-        @issue_prefix || DEFAULT_ISSUE_PREFIX
-      end
-
-      def severity_prefix
-        @severity_prefix || DEFAULT_SEVERITY_PREFIX
-      end
+require "allure_cucumber/formatter"
+require "allure_cucumber/config"
 
+module Allure
+  class << self
+    # Get allure cucumber configuration
+    # @return [Allure::CucumberConfig]
+    def configuration
+      CucumberConfig
     end
-  end
 
-  class << self
-    def configure(&block)
-      yield Config
-      AllureRubyAdaptorApi.configure do |c|
-        c.output_dir = Config.output_dir
-      end
+    # Set allure configuration
+    # @yieldparam [Allure::CucumberConfig]
+    # @yieldreturn [void]
+    # @return [void]
+    def configure
+      yield(CucumberConfig)
     end
   end
-
 end
+# rubocop:enable Naming/FileName

data/lib/allure_cucumber/ast_transformer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Cucumber::Core::Ast is removed in cucumber-core 4.0 version.
+# This will have to be updated accordingly, once stable version rolls out
+
+module Allure
+  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_case
+    # @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/config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Allure
+  class CucumberConfig < Config
+    class << self
+      DEFAULT_TMS_PREFIX = "TMS:"
+      DEFAULT_ISSUE_PREFIX = "ISSUE:"
+      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
+    end
+  end
+end

data/lib/allure_cucumber/cucumber_model.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "cucumber"
+require "cucumber/core"
+require "digest"
+require "csv"
+
+require_relative "ast_transformer"
+require_relative "tag_parser"
+
+module Allure
+  # Support class for transforming cucumber test entities in to allure model entities
+  class AllureCucumberModel
+    extend AstTransformer
+    extend TagParser
+
+    class << self
+      # Convert to allure test result
+      # @param [Cucumber::Core::Test::Case] test_case
+      # @return [TestResult]
+      def test_result(test_case)
+        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)
+        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
+        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
+
+      private
+
+      # Get thread specific lifecycle
+      # @return [Allure::AllureLifecycle]
+      def lifecycle
+        Allure.lifecycle
+      end
+
+      # @param [Cucumber::Core::Test::Case] test_case
+      # @return [Array<Allure::Label>]
+      def labels(test_case)
+        labels = []
+        labels << ResultUtils.framework_label("cucumber")
+        labels << ResultUtils.feature_label(test_case.feature.name)
+        labels << ResultUtils.package_label(test_case.feature.name)
+        labels << ResultUtils.suite_label(test_case.feature.name)
+        labels << ResultUtils.story_label(test_case.name)
+        labels << 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| 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", 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", ContentType::TXT)
+        lifecycle.write_attachment(multiline_arg.content, attachment)
+        attachment
+      end
+    end
+  end
+end

data/lib/allure_cucumber/formatter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "cucumber_model"
+
+module Allure
+  # Main formatter class. Translates cucumber event to allure lifecycle
+  class CucumberFormatter
+    HOOK_HANDLERS = {
+      "Before hook" => :start_prepare_fixture,
+      "After hook" => :start_tear_down_fixture,
+    }.freeze
+    ALLURE_STATUS = {
+      failed: Status::FAILED,
+      skipped: Status::SKIPPED,
+      passed: Status::PASSED,
+    }.freeze
+
+    # @param [Cucumber::Configuration] config
+    def initialize(config)
+      Allure::Config.results_directory = config.out_stream if config.out_stream.is_a?(String)
+      config.on_event(:test_case_started, &method(:on_test_case_started))
+      config.on_event(:test_step_started, &method(:on_test_step_started))
+      config.on_event(:test_step_finished, &method(:on_test_step_finished))
+      config.on_event(:test_case_finished, &method(:on_test_case_finished))
+    end
+
+    # Handle test case started event
+    # @param [Cucumber::Core::Events::TestCaseStarted] event
+    # @return [void]
+    def on_test_case_started(event)
+      lifecycle.start_test_container(TestResultContainer.new(name: event.test_case.name))
+      lifecycle.start_test_case(AllureCucumberModel.test_result(event.test_case))
+    end
+
+    # Handle test step started event
+    # @param [Cucumber::Core::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)
+    end
+
+    # Handle test step finished event
+    # @param [Cucumber::Core::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 = Stage::FINISHED
+        step.status = ALLURE_STATUS.fetch(event.result.to_sym, Status::BROKEN)
+      end
+      step_type = hook?(event.test_step) ? "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
+    # @return [void]
+    def on_test_case_finished(event)
+      failure_details = AllureCucumberModel.failure_details(event.result)
+      status = ALLURE_STATUS.fetch(event.result.to_sym, Status::BROKEN)
+      lifecycle.update_test_case do |test_case|
+        test_case.stage = Stage::FINISHED
+        test_case.status = event.result.failed? ? Allure::ResultUtils.status(event.result&.exception) : status
+        test_case.status_details.flaky = event.result.flaky?
+        test_case.status_details.message = failure_details[:message]
+        test_case.status_details.trace = failure_details[:trace]
+      end
+      lifecycle.stop_test_case
+      lifecycle.stop_test_container
+    end
+
+    private
+
+    # Get thread specific lifecycle
+    # @return [Allure::AllureLifecycle]
+    def lifecycle
+      Allure.lifecycle
+    end
+
+    # @param [Cucumber::Core::Test::Step] test_step <description>
+    # @return [Boolean]
+    def hook?(test_step)
+      HOOK_HANDLERS.key?(test_step.text)
+    end
+
+    # @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")
+    end
+
+    # @param [Cucumber::Core::Test::Step] test_step
+    # @return [void]
+    def handle_step_started(test_step)
+      lifecycle.start_test_step(AllureCucumberModel.step_result(test_step))
+    end
+
+    # @param [Cucumber::Core::Test::Step] test_step
+    # @return [void]
+    def handle_hook_started(test_step)
+      return if prepare_world_hook?(test_step)
+
+      lifecycle.public_send(HOOK_HANDLERS[test_step.text], AllureCucumberModel.fixture_result(test_step))
+    end
+  end
+end