allure-ruby-commons 2.13.8.1 → 2.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be70de370f6d6732ca70063312ccb4ffd0cf27ede2c50f53f7427ba718ce11d9
-  data.tar.gz: 67b723e4ef1b8092f279a27a9c250a093124b8f78c93dbc34a8655afc29420bd
+  metadata.gz: d63128392504c90df6eccbf93a5f3f0cd39e09d0a09c0b5365fc42ee54a07d90
+  data.tar.gz: e70469671849de4218ed7bd79368cde5cc6d8cdd8bbe495882c13b4cb58c1212
 SHA512:
-  metadata.gz: c10538c94a3334367b08d536db7f2449ef184201d7c5d95e02914c018ad4691b80dac94e898ee03d10e53f98741532afec30192b4e558be1ad19aeaf27324eb2
-  data.tar.gz: dad294ed8428f5e84a514203f8515cbe7241ebab5535ceb5163c2cf83df589ba5874ad5bd8aa3f820e5e18b42e92436567c96b8d5f5f3ab2554447ef1f4915b7
+  metadata.gz: 79249df603728c94f5a88cfe9879410b331ec1485f2a57be91a6805f10a2fb37211a98653a2719d33c74c5994ecbaa582deac15c6edd399dfde71da9db1af48d
+  data.tar.gz: 3f72dfec99534df2e5b661799814d36010074fa36d2702947dfbb80084cd22180915a4a96ac9d6da3b98c1ba685d335bacd0459b43f2a3ee59f910fadc4f198d

data/README.md

@@ -20,12 +20,23 @@ Following configuration options are supported:
 
 ```ruby
     Allure.configure do |config|
-      config.results_directory = "/whatever/you/like"
+      config.results_directory = "report/allure-results"
       config.clean_results_directory = true
       config.logging_level = Logger::INFO
+      config.logger = Logger.new($stdout, Logger::DEBUG)
+      config.environment = "staging"
+
       # these are used for creating links to bugs or test cases where {} is replaced with keys of relevant items
       config.link_tms_pattern = "http://www.jira.com/browse/{}"
       config.link_issue_pattern = "http://www.jira.com/browse/{}"
+
+      # additional metadata
+      # environment.properties
+      config.environment_properties = {
+        custom_attribute: "foo"
+      }
+      # categories.json
+      config.categories = File.new("my_custom_categories.json")
     end
 ```
 
@@ -35,6 +46,29 @@ Getting the configuration object:
 Allure.configuration
 ```
 
+### Allure execution environment
+
+It is possible to set up custom allure environment which will be used as custom parameter `environment` in every test case. This is useful if you run same tests on different environments and generate single report. This way different runs are not put as retry. Environment can be configured in following ways:
+
+* via `ALLURE_ENVIRONMENT` environment variable
+* via `configure` method
+
+### Environment properties
+
+To add additional environment information to the report it is possible to set configuration property `environment_properties`.
+
+Option can be set to hash or block returning a hash:
+
+```ruby
+# hash
+config.environment_properties = {
+        custom_attribute: "foo"
+      }
+
+# lambda
+config.environment_properties = -> { { custom_attributes: "foo"} }
+```
+
 ### Log level
 
 Log level can be also configured via environment variable `ALLURE_LOG_LEVEL` which accepts one of the following values: `DEBUG INFO WARN ERROR FATAL UNKNOWN`.
@@ -54,22 +88,19 @@ Allure.add_attachment(name: "attachment", source: "/path/to/test.txt", type: All
 Allure.add_link(name: "Custom Url", url: "http://www.github.com")
 ```
 
-## Testing
-
-Install dependencies:
+## Steps
 
-```bash
-bundle install
-```
-
-Run tests:
+It is possible to mark method definitions to be automatically added to report as steps. The class just needs to extend `AllureStepAnnotation`
+and `step` method needs to be used before the method definition.
 
-```bash
-bundle exec rspec
-```
+```ruby
+class TestHelper
+  extend AllureStepAnnotation
 
-## Building
+  step("Singleton step")
+  def self.class_method; end
 
-```bash
-gem build allure-ruby-commons.gemspec
+  step("Standard step")
+  def standard_method; end
+end
 ```

data/lib/allure-ruby-commons.rb

@@ -8,178 +8,240 @@ require_rel "allure_ruby_commons/**/*rb"
 
 # Namespace for classes that handle allure report generation and different framework adaptors
 module Allure
-  class << self
-    # Get thread specific allure lifecycle object
-    # @return [AllureLifecycle]
-    def lifecycle
-      Thread.current[:lifecycle] ||= AllureLifecycle.new
-    end
+  # Set lifecycle object
+  # @param [AllureLifecycle] lifecycle
+  # @return [void]
+  def self.lifecycle=(lifecycle)
+    Thread.current[:lifecycle] = lifecycle
+  end
 
-    # Set lifecycle object
-    # @param [AllureLifecycle] lifecycle
-    # @return [void]
-    def lifecycle=(lifecycle)
-      Thread.current[:lifecycle] = lifecycle
-    end
+  extend self # rubocop:disable Style/ModuleFunction
 
-    # Get allure configuration
-    # @return [Config]
-    def configuration
-      Config.instance
-    end
+  # Get thread specific allure lifecycle object
+  # @return [AllureLifecycle]
+  def lifecycle
+    Thread.current[:lifecycle] ||= AllureLifecycle.new
+  end
 
-    # Set allure configuration
-    # @yieldparam [Config]
-    # @yieldreturn [void]
-    # @return [void]
-    def configure
-      yield(configuration)
-    end
+  # Get allure configuration
+  # @return [Config]
+  def configuration
+    Config.instance
+  end
 
-    # Add epic to current test case
-    # @param [String] value
-    # @return [void]
-    def epic(value)
-      label(ResultUtils::EPIC_LABEL_NAME, value)
-    end
+  # Set allure configuration
+  # @yieldparam [Config]
+  # @yieldreturn [void]
+  # @return [void]
+  def configure
+    yield(configuration)
+  end
 
-    # Add feature to current test case
-    # @param [String] value
-    # @return [void]
-    def feature(value)
-      label(ResultUtils::FEATURE_LABEL_NAME, value)
-    end
+  # Add epic to current test case
+  # @param [String] value
+  # @return [void]
+  def epic(value)
+    replace_label(ResultUtils::EPIC_LABEL_NAME, value)
+  end
 
-    # Add story to current test case
-    # @param [String] value
-    # @return [void]
-    def story(value)
-      label(ResultUtils::STORY_LABEL_NAME, value)
-    end
+  # Add feature to current test case
+  # @param [String] value
+  # @return [void]
+  def feature(value)
+    replace_label(ResultUtils::FEATURE_LABEL_NAME, value)
+  end
 
-    # Add suite to current test case
-    # @param [String] value
-    # @return [void]
-    def suite(value)
-      label(ResultUtils::SUITE_LABEL_NAME, value)
-    end
+  # Add story to current test case
+  # @param [String] value
+  # @return [void]
+  def story(value)
+    replace_label(ResultUtils::STORY_LABEL_NAME, value)
+  end
 
-    # Add label to current test case
-    # @param [String] name
-    # @param [String] value
-    # @return [void]
-    def label(name, value)
-      lifecycle.update_test_case do |test_case|
-        test_case.labels.push(Label.new(name, value))
-      end
-    end
+  # Add suite to current test case
+  # @param [String] value
+  # @return [void]
+  def suite(value)
+    replace_label(ResultUtils::SUITE_LABEL_NAME, value)
+  end
 
-    # Add description to current test case
-    # @param [String] description
-    # @return [void]
-    def add_description(description)
-      lifecycle.update_test_case do |test_case|
-        test_case.description = description
-      end
-    end
+  # Add tag to current test case
+  # @param [String] value
+  # @return [void]
+  def tag(value)
+    label(ResultUtils::TAG_LABEL_NAME, value)
+  end
 
-    # Add html description to current test case
-    # @param [String] description_html
-    # @return [void]
-    def description_html(description_html)
-      lifecycle.update_test_case do |test_case|
-        test_case.description_html = description_html
-      end
+  # Add label to current test case
+  # @param [String] name
+  # @param [String] value
+  # @return [void]
+  def label(name, value)
+    lifecycle.update_test_case do |test_case|
+      test_case.labels.push(Label.new(name, value))
     end
+  end
 
-    # Add parameter to current test case
-    # @param [String] name
-    # @param [String] value
-    # @return [void]
-    def parameter(name, value)
-      lifecycle.update_test_case do |test_case|
-        test_case.parameters.push(Parameter.new(name, value))
-      end
+  # Replace label in current test case
+  #
+  # @param [String] name
+  # @param [String] value
+  # @return [void]
+  def replace_label(name, value)
+    lifecycle.update_test_case do |test_case|
+      present = test_case.labels.detect { |l| l.name == name }
+      return label(name, value) unless present
+
+      test_case.labels.map! { |l| l.name == name ? Label.new(name, value) : l }
     end
+  end
 
-    # Add tms link to current test case
-    # @param [String] name
-    # @param [String] url
-    # @return [void]
-    def tms(name, url)
-      add_link(name: name, url: url, type: ResultUtils::TMS_LINK_TYPE)
+  # Add description to current test case
+  # @param [String] description
+  # @return [void]
+  def add_description(description)
+    lifecycle.update_test_case do |test_case|
+      test_case.description = description
     end
+  end
 
-    # Add issue linkt to current test case
-    # @param [String] name
-    # @param [String] url
-    # @return [void]
-    def issue(name, url)
-      add_link(name: name, url: url, type: ResultUtils::ISSUE_LINK_TYPE)
+  # Add html description to current test case
+  # @param [String] description_html
+  # @return [void]
+  def description_html(description_html)
+    lifecycle.update_test_case do |test_case|
+      test_case.description_html = description_html
     end
+  end
 
-    # Add link to current test case
-    # @param [String ] url
-    # @param [String] name
-    # @param [String] type type of the link used to display link icon
-    # @return [void]
-    def add_link(url:, name: nil, type: "custom")
-      lifecycle.update_test_case do |test_case|
-        test_case.links.push(Link.new(type, name || url, url))
-      end
+  # Add parameter to current test case
+  # @param [String] name
+  # @param [String] value
+  # @return [void]
+  def parameter(name, value)
+    lifecycle.update_test_case do |test_case|
+      test_case.parameters.push(Parameter.new(name, value))
     end
+  end
 
-    # Add attachment to current test case or step
-    # @param [String] name Attachment name
-    # @param [File, String] source File or string to save as attachment
-    # @param [String] type attachment type defined in {ContentType} or any other valid mime type
-    # @param [Boolean] test_case add attachment to current test case instead of test step
-    # @return [void]
-    def add_attachment(name:, source:, type:, test_case: false)
-      lifecycle.add_attachment(name: name, source: source, type: type, test_case: test_case)
+  # Add tms link to current test case
+  # @param [String] name
+  # @param [String] url
+  # @return [void]
+  def tms(name, url)
+    add_link(name: name, url: url, type: ResultUtils::TMS_LINK_TYPE)
+  end
+
+  # Add issue linkt to current test case
+  # @param [String] name
+  # @param [String] url
+  # @return [void]
+  def issue(name, url)
+    add_link(name: name, url: url, type: ResultUtils::ISSUE_LINK_TYPE)
+  end
+
+  # Add link to current test case
+  # @param [String ] url
+  # @param [String] name
+  # @param [String] type type of the link used to display link icon
+  # @return [void]
+  def add_link(url:, name: nil, type: "custom")
+    lifecycle.update_test_case do |test_case|
+      test_case.links.push(Link.new(type, name || url, url))
     end
+  end
 
-    # Add allure report environment info
-    # @param [Hash<Symbol, String>] environment
-    # @return [void]
-    def add_environment(environment)
-      lifecycle.write_environment(environment)
+  # Add attachment to current test case or step
+  # @param [String] name Attachment name
+  # @param [File, String] source File or string to save as attachment
+  # @param [String] type attachment type defined in {ContentType} or any other valid mime type
+  # @param [Boolean] test_case add attachment to current test case instead of test step
+  # @return [void]
+  def add_attachment(name:, source:, type:, test_case: false)
+    lifecycle.add_attachment(name: name, source: source, type: type, test_case: test_case)
+  end
+
+  # Manually create environment.properties file
+  #   if this method is called before test run started and
+  #   option clean_results_directory is enabled, the file will be deleted
+  # @param [Hash<Symbol, String>, Proc] environment
+  # @return [void]
+  def add_environment(environment)
+    lifecycle.write_environment(environment)
+  end
+
+  # Manually create categories.json file
+  #   if this method is called before test run started and
+  #   option clean_results_directory is enabled, the file will be deleted
+  # @param [File, Array<Category>] categories
+  # @return [void]
+  def add_categories(categories)
+    lifecycle.write_categories(categories)
+  end
+
+  # Set test case status detail to flaky
+  #
+  # @return [void]
+  def set_flaky
+    lifecycle.update_test_case do |test_case|
+      test_case.status_details.flaky = true
     end
+  end
 
-    # Add categories info
-    # @param [File, Array<Category>] categories
-    # @return [void]
-    def add_categories(categories)
-      lifecycle.write_categories(categories)
+  # Set test case status detail to muted
+  #
+  # @return [void]
+  def set_muted
+    lifecycle.update_test_case do |test_case|
+      test_case.status_details.muted = true
     end
+  end
 
-    # Add step with provided name and optional status to current test step, fixture or test case
-    # @param [String] name
-    # @param [Symbol] status {Status}, {Status::PASSED} by default
-    # @return [void]
-    def step(name:, status: nil)
-      lifecycle.add_test_step(StepResult.new(name: name, status: status || Status::PASSED, stage: Stage::FINISHED))
-      lifecycle.stop_test_step
+  # Set test case status detail to known
+  #
+  # @return [void]
+  def set_known
+    lifecycle.update_test_case do |test_case|
+      test_case.status_details.known = true
     end
+  end
+
+  # Add step with provided name and optional status to current test step, fixture or test case
+  # @param [String] name
+  # @param [Symbol] status {Status}, {Status::PASSED} by default
+  # @return [void]
+  def step(name:, status: nil)
+    lifecycle.add_test_step(StepResult.new(name: name, status: status || Status::PASSED, stage: Stage::FINISHED))
+    lifecycle.stop_test_step
+  end
+
+  # Run passed block as step with given name and return result of yield
+  # @param [String] name
+  # @yield [] step block
+  # @return [Object]
+  def run_step(name)
+    lifecycle.start_test_step(StepResult.new(name: name, stage: Stage::RUNNING))
+    result = yield
+    lifecycle.update_test_step { |step| step.status = Status::PASSED }
+
+    result
+  rescue StandardError => e
+    lifecycle.update_test_step do |step|
+      step.status = ResultUtils.status(e)
+      step.status_details = ResultUtils.status_details(e)
+    end
+    raise(e)
+  ensure
+    lifecycle.stop_test_step
+  end
 
-    # Run passed block as step with given name and return result of yield
-    # @param [String] name
-    # @yield [] step block
-    # @return [Object]
-    def run_step(name)
-      lifecycle.start_test_step(StepResult.new(name: name, stage: Stage::RUNNING))
-      result = yield
-      lifecycle.update_test_step { |step| step.status = Status::PASSED }
-
-      result
-    rescue StandardError => e
-      lifecycle.update_test_step do |step|
-        step.status = ResultUtils.status(e)
-        step.status_details = ResultUtils.status_details(e)
-      end
-      raise(e)
-    ensure
-      lifecycle.stop_test_step
+  # Add parameter to current test step
+  # @param [String] name
+  # @param [String] value
+  # @return [void]
+  def step_parameter(name, value)
+    lifecycle.update_test_step do |step|
+      step.parameters.push(Parameter.new(name, value))
     end
   end
 end

data/lib/allure_ruby_commons/allure_lifecycle.rb

@@ -8,14 +8,19 @@ module Allure
   class AllureLifecycle # rubocop:disable Metrics/ClassLength
     extend Forwardable
 
-    def initialize
+    # Allure lifecycle instance
+    #
+    # @param [Allure::Config] configuration
+    def initialize(config = Config.instance)
       @test_context = []
       @step_context = []
-      @logger = Logger.new($stdout, level: Config.instance.logging_level)
-      @file_writer = FileWriter.new
+      @config = config
+      @logger = config.logger
     end
 
-    def_delegators :file_writer, :write_attachment, :write_environment, :write_categories
+    attr_reader :config
+
+    def_delegators :file_writer, :write_attachment
 
     # Start test result container
     # @param [Allure::TestResultContainer] test_result_container
@@ -215,6 +220,27 @@ module Allure
       write_attachment(source, attachment)
     end
 
+    # Add environment.properties file
+    #
+    # @param [Hash, Proc] env
+    # @return [void]
+    def write_environment(env = config.environment_properties)
+      return unless env
+
+      env_properties = env.respond_to?(:call) ? env.call : env
+      file_writer.write_environment(env_properties)
+    end
+
+    # Add categories.json
+    #
+    # @param [File, Array<Category>] categories
+    # @return [void]
+    def write_categories(categories = config.categories)
+      return unless categories
+
+      file_writer.write_categories(categories)
+    end
+
     # Add step to current fixture|step|test case
     # @param [Allure::StepResult] step_result
     # @return [Allure::StepResult]
@@ -227,14 +253,16 @@ module Allure
     # Clean results directory
     # @return [void]
     def clean_results_dir
-      Allure.configuration.tap do |c|
-        FileUtils.rm_f(Dir.glob("#{c.results_directory}/**/*")) if c.clean_results_directory
-      end
+      FileUtils.rm_f(Dir.glob("#{config.results_directory}/**/*")) if config.clean_results_directory
     end
 
     private
 
-    attr_accessor :logger, :file_writer
+    attr_reader :logger
+
+    def file_writer
+      @file_writer ||= FileWriter.new(config.results_directory)
+    end
 
     def current_executable
       current_test_step || @current_fixture || @current_test_case

data/lib/allure_ruby_commons/config.rb

@@ -10,41 +10,36 @@ module Allure
 
     # @return [Array<String>] valid log levels
     LOGLEVELS = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
-    # @return [String] test plan path env var name
-    TESTPLAN_PATH = "ALLURE_TESTPLAN_PATH"
 
-    attr_accessor :results_directory, :logging_level, :link_tms_pattern, :link_issue_pattern, :clean_results_directory
+    attr_writer :environment, :logger
+
+    attr_accessor :results_directory,
+                  :logging_level,
+                  :link_tms_pattern,
+                  :link_issue_pattern,
+                  :clean_results_directory,
+                  :environment_properties,
+                  :categories
 
     def initialize
       @results_directory = "reports/allure-results"
       @logging_level = LOGLEVELS.index(ENV.fetch("ALLURE_LOG_LEVEL", "INFO")) || Logger::INFO
     end
 
-    # Allure id's of executable tests
+    # Allure environment
     #
-    # @return [Array]
-    def test_ids
-      @test_ids ||= tests&.map { |test| test[:id] }
-    end
+    # @return [String]
+    def environment
+      return(@environment) if defined?(@environment)
 
-    # Test names of executable tests
-    #
-    # @return [Array]
-    def test_names
-      @test_names ||= tests&.map { |test| test[:selector] }
+      @environment ||= ENV["ALLURE_ENVIRONMENT"]
     end
 
-    private
-
-    # Tests to execute from allure testplan.json
+    # Logger instance
     #
-    # @return [Array<Hash>]
-    def tests
-      @tests ||= begin
-        Oj.load_file(ENV[TESTPLAN_PATH], symbol_keys: true)&.fetch(:tests) if ENV[TESTPLAN_PATH]
-      end
-    rescue Oj::ParseError
-      nil
+    # @return [Logger]
+    def logger
+      @logger ||= Logger.new($stdout, level: logging_level)
     end
   end
 end

data/lib/allure_ruby_commons/file_writer.rb

@@ -13,19 +13,28 @@ module Allure
     ENVIRONMENT_FILE = "environment.properties"
     # @return [String] categories definition json
     CATEGORIES_FILE = "categories.json"
+    # @return [Hash] Oj json options
+    OJ_OPTIONS = { mode: :custom, use_to_hash: true, ascii_only: true }.freeze
+
+    # File writer instance
+    #
+    # @param [String] results_directory
+    def initialize(results_directory)
+      @results_directory = results_directory
+    end
 
     # Write test result
     # @param [Allure::TestResult] test_result
     # @return [void]
     def write_test_result(test_result)
-      write("#{test_result.uuid}#{TEST_RESULT_SUFFIX}", Oj.dump(test_result))
+      write("#{test_result.uuid}#{TEST_RESULT_SUFFIX}", Oj.dump(test_result, OJ_OPTIONS))
     end
 
     # Write test result container
     # @param [Allure::TestResultContainer] test_container_result
     # @return [void]
     def write_test_result_container(test_container_result)
-      write("#{test_container_result.uuid}#{TEST_RESULT_CONTAINER_SUFFIX}", Oj.dump(test_container_result))
+      write("#{test_container_result.uuid}#{TEST_RESULT_CONTAINER_SUFFIX}", Oj.dump(test_container_result, OJ_OPTIONS))
     end
 
     # Write allure attachment file
@@ -52,19 +61,21 @@ module Allure
       if categories.is_a?(File)
         copy(categories.path, CATEGORIES_FILE)
       else
-        write(CATEGORIES_FILE, Oj.dump(categories))
+        write(CATEGORIES_FILE, Oj.dump(categories, OJ_OPTIONS))
       end
     end
 
     private
 
+    attr_reader :results_directory
+
     def output_dir
-      @output_dir ||= FileUtils.mkpath(Config.instance.results_directory).first
+      @output_dir ||= FileUtils.mkpath(results_directory).first
     end
 
     def write(name, source)
       filename = File.join(output_dir, name)
-      File.open(filename, "w") { |file| file.write(source) }
+      File.write(filename, source)
     end
 
     def copy(from, to)

data/lib/allure_ruby_commons/model/01_jsonable.rb

@@ -5,8 +5,6 @@ require "oj"
 module Allure
   # General jsonable object implementation
   class JSONable
-    Oj.default_options = { mode: :custom, use_to_hash: true, ascii_only: true }
-
     # Return object hash represantation
     # @return [Hash]
     def to_hash

data/lib/allure_ruby_commons/model/executable_item.rb

@@ -27,9 +27,16 @@ module Allure
       @parameters = options[:parameters] || []
     end
 
-    attr_accessor(
-      :name, :status, :status_details, :stage, :description, :description_html,
-      :steps, :attachments, :parameters, :start, :stop
-    )
+    attr_accessor :name,
+                  :status,
+                  :status_details,
+                  :stage,
+                  :description,
+                  :description_html,
+                  :steps,
+                  :attachments,
+                  :parameters,
+                  :start,
+                  :stop
   end
 end

data/lib/allure_ruby_commons/model/test_result.rb

@@ -5,6 +5,7 @@ module Allure
   class TestResult < ExecutableItem
     # @param [String] uuid
     # @param [String] history_id
+    # @param [String] environment
     # @param [Hash] options
     # @option options [String] :name
     # @option options [String] :full_name
@@ -18,15 +19,22 @@ module Allure
     # @option options [Array<Allure::Link>] :links ([])
     # @option options [Array<Allure::Attachment>] :attachments ([])
     # @option options [Array<Allure::Parameter>] :parameters ([])
-    def initialize(uuid: UUID.generate, history_id: UUID.generate, **options)
+    def initialize(uuid: UUID.generate, history_id: UUID.generate, environment: nil, **options)
       super
+
+      @name = options[:name]
       @uuid = uuid
-      @history_id = history_id
+      @history_id = Digest::MD5.hexdigest("#{history_id}#{environment}")
       @full_name = options[:full_name] || "Unnamed"
       @labels = options[:labels] || []
       @links = options[:links] || []
+      @parameters << Parameter.new("environment", environment) if environment
     end
 
-    attr_accessor :uuid, :history_id, :full_name, :labels, :links
+    attr_accessor :uuid,
+                  :history_id,
+                  :full_name,
+                  :labels,
+                  :links
   end
 end

data/lib/allure_ruby_commons/result_utils.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
+require "uri"
 
 module Allure
   # Variouse helper methods
@@ -59,6 +60,13 @@ module Allure
         Label.new(FRAMEWORK_LABEL_NAME, value)
       end
 
+      # Epic label
+      # @param [String] value
+      # @return [Allure::Label]
+      def epic_label(value)
+        Label.new(EPIC_LABEL_NAME, value)
+      end
+
       # Feature label
       # @param [String] value
       # @return [Allure::Label]
@@ -66,6 +74,13 @@ module Allure
         Label.new(FEATURE_LABEL_NAME, value)
       end
 
+      # Story label
+      # @param [String] value
+      # @return [Allure::Label]
+      def story_label(value)
+        Label.new(STORY_LABEL_NAME, value)
+      end
+
       # Package label
       # @param [String] value
       # @return [Allure::Label]
@@ -94,13 +109,6 @@ module Allure
         Label.new(SUB_SUITE_LABEL_NAME, value)
       end
 
-      # Story label
-      # @param [String] value
-      # @return [Allure::Label]
-      def story_label(value)
-        Label.new(STORY_LABEL_NAME, value)
-      end
-
       # Test case label
       # @param [String] value
       # @return [Allure::Label]
@@ -124,16 +132,20 @@ module Allure
 
       # TMS link
       # @param [String] value
+      # @param [String] link_pattern
       # @return [Allure::Link]
-      def tms_link(value)
-        Link.new(TMS_LINK_TYPE, value, tms_url(value))
+      def tms_link(name, value, link_pattern)
+        link_name = url?(value) ? name : value
+        Link.new(TMS_LINK_TYPE, link_name, url(value, link_pattern))
       end
 
       # Issue link
       # @param [String] value
+      # @param [String] link_pattern
       # @return [Allure::Link]
-      def issue_link(value)
-        Link.new(ISSUE_LINK_TYPE, value, issue_url(value))
+      def issue_link(name, value, link_pattern)
+        link_name = url?(value) ? name : value
+        Link.new(ISSUE_LINK_TYPE, link_name, url(value, link_pattern))
       end
 
       # Get status based on exception type
@@ -162,12 +174,21 @@ module Allure
 
       private
 
-      def tms_url(value)
-        Allure.configuration.link_tms_pattern.sub("{}", value)
+      # Check if value is full url
+      #
+      # @param [String] value
+      # @return [Boolean]
+      def url?(value)
+        URI.parse(value.to_s).scheme
       end
 
-      def issue_url(value)
-        Allure.configuration.link_issue_pattern.sub("{}", value)
+      # Construct url from pattern
+      #
+      # @param [String] value
+      # @param [String] link_pattern
+      # @return [String]
+      def url(value, link_pattern)
+        link_pattern.sub("{}", value)
       end
     end
   end

data/lib/allure_ruby_commons/step_annotation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Adds support for annotating methods as allure steps
+#
+module AllureStepAnnotation
+  # Mark method definition as allure step
+  #
+  # @param [String] step_name
+  # @return [void]
+  def step(step_name = "")
+    @allure_step = step_name
+  end
+
+  private
+
+  def singleton_method_added(method_name)
+    return super unless @allure_step
+
+    original_method = singleton_method(method_name)
+    step_name = @allure_step.empty? ? method_name.to_s : @allure_step
+    @allure_step = nil
+
+    define_singleton_method(method_name) do |*args, &block|
+      Allure.run_step(step_name) { original_method.call(*args, &block) }
+    end
+  end
+
+  def method_added(method_name)
+    return super unless @allure_step
+
+    original_method = instance_method(method_name)
+    step_name = @allure_step.empty? ? method_name.to_s : @allure_step
+    @allure_step = nil
+
+    define_method(method_name) do |*args, &block|
+      Allure.run_step(step_name) { original_method.bind_call(self, *args, &block) }
+    end
+  end
+end

data/lib/allure_ruby_commons/testplan.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Allure
+  class TestPlan
+    # @return [String] test plan path env var name
+    TESTPLAN_PATH = "ALLURE_TESTPLAN_PATH"
+
+    class << self
+      # Allure id's of executable tests
+      #
+      # @return [Array]
+      def test_ids
+        @test_ids ||= tests&.map { |test| test[:id] }
+      end
+
+      # Test names of executable tests
+      #
+      # @return [Array]
+      def test_names
+        @test_names ||= tests&.map { |test| test[:selector] }
+      end
+
+      private
+
+      # Tests to execute from allure testplan.json
+      #
+      # @return [Array<Hash>]
+      def tests
+        @tests ||= Oj.load_file(ENV[TESTPLAN_PATH], symbol_keys: true)&.fetch(:tests) if ENV[TESTPLAN_PATH]
+      rescue Oj::ParseError
+        nil
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allure-ruby-commons
 version: !ruby/object:Gem::Version
-  version: 2.13.8.1
+  version: 2.19.0
 platform: ruby
 authors:
 - Andrejs Cunskis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-14 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types
@@ -118,6 +118,8 @@ files:
 - lib/allure_ruby_commons/model/test_result.rb
 - lib/allure_ruby_commons/model/test_result_container.rb
 - lib/allure_ruby_commons/result_utils.rb
+- lib/allure_ruby_commons/step_annotation.rb
+- lib/allure_ruby_commons/testplan.rb
 homepage: https://github.com/allure-framework/allure-ruby
 licenses:
 - Apache-2.0
@@ -127,6 +129,7 @@ metadata:
   documentation_uri: https://github.com/allure-framework/allure-ruby/blob/master/allure-ruby-commons/README.md
   source_code_uri: https://github.com/allure-framework/allure-ruby/tree/master/allure-ruby-commons
   wiki_uri: https://github.com/allure-framework/allure-ruby/wiki
+  rubygems_mfa_required: 'false'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -135,14 +138,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Common library for allure results generation