allure-ruby-commons 2.10.0.beta2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c6ec9c5dd1a69617de027bd146f0deaf35ef51a1bd8861e013c41550070020b7
+  data.tar.gz: e049c7285aed91e6c8aceb3185ed4a11f143aaafb5b8ae20acdf996c1239f923
+SHA512:
+  metadata.gz: 1367a4de864e0c704ac5223b626a8027bdb942aaa91ceac3e25b84ec228b86e6b4f4204c3439b55f8f8a9d5860e3b044877da910aa70270a19d1ee5a4f9be5f0
+  data.tar.gz: 626e8aa40a5d8f7cde655ca3b6a7f1b283a5006d80676aa86001e63986f25e674220cfabaff63d8f607a6381f9221e493cbed4d88e1f4833da6e570637b343f5

data/README.md

@@ -0,0 +1,67 @@
+# Allure Ruby Adaptor API
+
+This is a helper library containing the basics for any ruby-based Allure adaptor.
+Using it you can easily implement the adaptor for your favorite ruby testing library or
+you can just create the report of any other kind using the basic Allure terms.
+
+## Setup
+
+Add the dependency to your Gemfile
+
+```ruby
+ gem 'allure-ruby-commons'
+```
+
+## Configuration
+
+Following configuration options are supported:
+
+```ruby
+    Allure.configure do |c|
+      c.results_directory = "/whatever/you/like"
+      c.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/{}"
+    end
+```
+
+Getting the configuration object:
+
+```ruby
+Allure.configuration
+```
+
+## Allure lifecycle
+
+Reports are built using API defined in AllureLifecycle class and using allure specific entities defined in models.
+Example of building a simple test case can be seen in [integration spec](spec/integration/full_report_spec.rb).
+
+Convenience method `Allure.lifecycle` exists for getting thread specific allure lifecycle instance.
+
+Additional methods in [Allure](lib/allure-ruby-commons.rb) exist to add various custom attributes to test report.
+
+```ruby
+Allure.add_attachment(name: "attachment", source: "Some string", type: Allure::ContentType::TXT, test_case: false)
+Allure.add_link(name: "Custom Url", url: "http://www.github.com")
+```
+
+## Testing
+
+Install dependencies:
+
+```bash
+bundle install
+```
+
+Run tests:
+
+```bash
+bundle exec rspec
+```
+
+## Building
+
+```bash
+gem build allure-ruby-commons.gemspec
+```

data/lib/allure-ruby-commons.rb

@@ -0,0 +1,168 @@
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
+
+require "require_all"
+require "uuid"
+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 [Allure::AllureLifecycle]
+    def lifecycle
+      Thread.current[:lifecycle] ||= AllureLifecycle.new
+    end
+
+    # Set lifecycle object
+    # @param [Allure::AllureLifecycle] lifecycle
+    # @return [void]
+    def lifecycle=(lifecycle)
+      Thread.current[:lifecycle] = lifecycle
+    end
+
+    # Get allure configuration
+    # @return [Allure::Config]
+    def configuration
+      Config
+    end
+
+    # Set allure configuration
+    # @yieldparam [Allure::Config]
+    # @yieldreturn [void]
+    # @return [void]
+    def configure
+      yield(Config)
+    end
+
+    # Add epic to current test case
+    # @param [String] value
+    # @return [void]
+    def epic(value)
+      label(ResultUtils::EPIC_LABEL_NAME, value)
+    end
+
+    # Add feature to current test case
+    # @param [String] value
+    # @return [void]
+    def feature(value)
+      label(ResultUtils::FEATURE_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 suite to current test case
+    # @param [String] value
+    # @return [void]
+    def suite(value)
+      label(ResultUtils::SUITE_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 description to current test case
+    # @param [String] description
+    # @return [void]
+    def description(description)
+      lifecycle.update_test_case do |test_case|
+        test_case.description = description
+      end
+    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
+    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 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 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 {Allure::ContentType}
+    # @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
+
+    # Add step with provided name and optional status to current test step, fixture or test case
+    # @param [String] name
+    # @param [Symbol] status <Allure::Status>, <Allure::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))
+    end
+
+    # Run passed block as step with given name
+    # @param [String] name
+    # @yield [] step block
+    # @return [void]
+    def run_step(name)
+      lifecycle.start_test_step(StepResult.new(name: name, stage: Stage::RUNNING))
+      yield
+      lifecycle.update_test_step { |step| step.status = Status::PASSED }
+    rescue => 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
+  end
+end
+# rubocop:enable Naming/FileName

data/lib/allure_ruby_commons/allure_lifecycle.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Allure
+  # Main class for creating and writing allure results
+  class AllureLifecycle
+    def initialize
+      @step_context = []
+    end
+
+    # Start test result container
+    # @param [Allure::TestResultContainer] test_result_container
+    # @return [Allure::TestResultContainer]
+    def start_test_container(test_result_container)
+      test_result_container.start = ResultUtils.timestamp
+      @current_test_result_container = test_result_container
+    end
+
+    # @example Update current test container
+    #   update_test_container do |container|
+    #     container.stage = Allure::Stage::FINISHED
+    #   end
+    # @yieldparam [Allure::TestResultContainer] current test result container
+    # @yieldreturn [void]
+    # @return [void]
+    def update_test_container
+      unless @current_test_result_container
+        return logger.error("Could not update test container, no container is running.")
+      end
+
+      yield(@current_test_result_container)
+    end
+
+    # Stop current test container and write result
+    # @return [void]
+    def stop_test_container
+      unless @current_test_result_container
+        return logger.error("Could not stop test container, no container is running.")
+      end
+
+      @current_test_result_container.stop = ResultUtils.timestamp
+      file_writer.write_test_result_container(@current_test_result_container)
+      clear_current_test_container
+    end
+
+    # Start test case and add to current test container
+    # @param [Allure::TestResult] test_result
+    # @return [Allure::TestResult]
+    def start_test_case(test_result)
+      clear_step_context
+      unless @current_test_result_container
+        return logger.error("Could not start test case, test container is not started")
+      end
+
+      test_result.start = ResultUtils.timestamp
+      test_result.stage = Stage::RUNNING
+      test_result.labels.push(ResultUtils.thread_label, ResultUtils.host_label, ResultUtils.language_label)
+      @current_test_result_container.children.push(test_result.uuid)
+      @current_test_case = test_result
+    end
+
+    # @example Update current test case
+    #   update_test_container do |test_case|
+    #     test_case.status = Allure::Status::FAILED
+    #   end
+    # @yieldparam [Allure::TestResult] current test
+    # @yieldreturn [void]
+    # @return [void]
+    def update_test_case
+      return logger.error("Could not update test case, no test case running") unless @current_test_case
+
+      yield(@current_test_case)
+    end
+
+    # Stop current test case and write result
+    # @return [void]
+    def stop_test_case
+      return logger.error("Could not stop test case, no test case is running") unless @current_test_case
+
+      @current_test_case.stop = ResultUtils.timestamp
+      @current_test_case.stage = Stage::FINISHED
+      file_writer.write_test_result(@current_test_case)
+      clear_current_test_case
+      clear_step_context
+    end
+
+    # Start test step and add to current test case
+    # @param [Allure::StepResult] step_result
+    # @return [Allure::StepResult]
+    def start_test_step(step_result)
+      return logger.error("Could not start test step, no test case is running") unless @current_test_case
+
+      step_result.start = ResultUtils.timestamp
+      step_result.stage = Stage::RUNNING
+      add_test_step(step_result)
+      step_result
+    end
+
+    # @example Update current test step
+    #   update_test_container do |test_step|
+    #     test_step.status = Allure::Status::BROKEN
+    #   end
+    # @yieldparam [Allure::StepResult] current test step
+    # @yieldreturn [void]
+    # @return [void]
+    def update_test_step
+      return logger.error("Could not update test step, no step is running") unless current_test_step
+
+      yield(current_test_step)
+    end
+
+    # Stop current test step
+    # @return [void]
+    def stop_test_step
+      return logger.error("Could not stop test step, no step is running") unless current_test_step
+
+      current_test_step.stop = ResultUtils.timestamp
+      current_test_step.stage = Stage::FINISHED
+      clear_last_test_step
+    end
+
+    # Start prepare fixture
+    # @param [Allure::FixtureResult] fixture_result
+    # @return [Allure::FixtureResult]
+    def start_prepare_fixture(fixture_result)
+      start_fixture(fixture_result) || return
+      @current_test_result_container.befores.push(fixture_result)
+      @current_fixture = fixture_result
+    end
+
+    # Start tear down fixture
+    # @param [Allure::FixtureResult] fixture_result
+    # @return [Allure::FixtureResult]
+    def start_tear_down_fixture(fixture_result)
+      start_fixture(fixture_result) || return
+      @current_test_result_container.afters.push(fixture_result)
+      @current_fixture = fixture_result
+    end
+
+    # Start fixture
+    # @param [Allure::FixtureResult] fixture_result
+    # @return [Allure::FixtureResult]
+    def start_fixture(fixture_result)
+      clear_step_context
+      unless @current_test_result_container
+        logger.error("Could not start fixture, test container is not started")
+        return false
+      end
+
+      fixture_result.start = ResultUtils.timestamp
+      fixture_result.stage = Stage::RUNNING
+    end
+
+    # @example Update current fixture
+    #   update_test_container do |fixture|
+    #     fixture.status = Allure::Status::BROKEN
+    #   end
+    # @yieldparam [Allure::FixtureResult] current fixture
+    # @yieldreturn [void]
+    # @return [void]
+    def update_fixture
+      return logger.error("Could not update fixture, fixture is not started") unless @current_fixture
+
+      yield(@current_fixture)
+    end
+
+    def stop_fixture
+      return logger.error("Could not stop fixture, fixture is not started") unless @current_fixture
+
+      @current_fixture.stop = ResultUtils.timestamp
+      @current_fixture.stage = Stage::FINISHED
+      clear_current_fixture
+      clear_step_context
+    end
+
+    # Add attachment to current test 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 {Allure::ContentType}
+    # @param [Boolean] test_case add attachment to current test case
+    # @return [void]
+    def add_attachment(name:, source:, type:, test_case: false)
+      attachment = prepare_attachment(name, type) || begin
+        return logger.error("Can't add attachment, unrecognized mime type: #{type}")
+      end
+      executable_item = (test_case && @current_test_case) || current_executable
+      executable_item&.attachments&.push(attachment) || begin
+        return logger.error("Can't add attachment, no test, step or fixture is running")
+      end
+      write_attachment(source, attachment)
+    end
+
+    # Create attachment object
+    # @param [String] name
+    # @param [String] type
+    # @return [Allure::Attachment]
+    def prepare_attachment(name, type)
+      extension = ContentType.to_extension(type) || return
+      file_name = "#{UUID.generate}-attachment.#{extension}"
+      Attachment.new(name: name, source: file_name, type: type)
+    end
+
+    # Write attachment file
+    # @param [File, String] source
+    # @param [Allure::Attachment] attachment
+    # @return [void]
+    def write_attachment(source, attachment)
+      file_writer.write_attachment(source, attachment)
+    end
+
+    # Add step to current fixture|step|test case
+    # @param [Allure::StepResult] step_result
+    # @return [Allure::StepResult]
+    def add_test_step(step_result)
+      current_executable.steps.push(step_result)
+      @step_context.push(step_result)
+      step_result
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new(STDOUT, level: Config.logging_level)
+    end
+
+    def file_writer
+      @file_writer ||= FileWriter.new
+    end
+
+    def current_executable
+      current_test_step || @current_fixture || @current_test_case
+    end
+
+    def clear_current_test_container
+      @current_test_result_container = nil
+    end
+
+    def clear_current_test_case
+      @current_test_case = nil
+    end
+
+    def current_test_step
+      @step_context.last
+    end
+
+    def clear_last_test_step
+      @step_context.pop
+    end
+
+    def clear_step_context
+      @step_context.clear
+    end
+
+    def clear_current_fixture
+      @current_fixture = nil
+    end
+  end
+end

data/lib/allure_ruby_commons/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Allure
+  class Config
+    DEFAULT_RESULTS_DIRECTORY = "reports/allure-results"
+    DEFAULT_LOGGING_LEVEL = Logger::INFO
+
+    class << self
+      attr_accessor :link_tms_pattern, :link_issue_pattern
+      attr_writer :results_directory, :logging_level
+
+      def results_directory
+        @results_directory || DEFAULT_RESULTS_DIRECTORY
+      end
+
+      def logging_level
+        @logging_level || DEFAULT_LOGGING_LEVEL
+      end
+    end
+  end
+end

data/lib/allure_ruby_commons/file_writer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Allure
+  class FileWriter
+    TEST_RESULT_SUFFIX = "-result.json"
+    TEST_RESULT_CONTAINER_SUFFIX = "-container.json"
+    ATTACHMENT_FILE_SUFFIX = "-attachment"
+
+    # Write test result
+    # @param [Allure::TestResult] test_result
+    # @return [void]
+    def write_test_result(test_result)
+      write("#{test_result.uuid}#{TEST_RESULT_SUFFIX}", test_result.to_json)
+    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}", test_container_result.to_json)
+    end
+
+    # Write allure attachment file
+    # @param [File, String] source File or string of attachment to save
+    # @param [Allure::Attachment] attachment
+    # @return [void]
+    def write_attachment(source, attachment)
+      source.is_a?(File) ? copy(source.path, attachment.source) : write(attachment.source, source)
+    end
+
+    private
+
+    def output_dir
+      @output_dir ||= FileUtils.mkpath(Allure::Config.results_directory).first
+    end
+
+    def write(name, source)
+      filename = File.join(output_dir, name)
+      File.open(filename, "w") { |file| file.write(source) }
+    end
+
+    def copy(from, to)
+      FileUtils.cp(from, File.join(output_dir, to))
+    end
+  end
+end

data/lib/allure_ruby_commons/model/attachment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+
+module Allure
+  class Attachment < JSONable
+    # @param [String] name attachment name
+    # @param [String] type attachment type, {Allure::ContentType}
+    # @param [String] source attachment file name
+    def initialize(name:, type:, source:)
+      @name = name
+      @type = type
+      @source = source
+    end
+
+    attr_accessor :name, :type, :source
+  end
+end

data/lib/allure_ruby_commons/model/content_type.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Allure
+  class ContentType
+    TXT = "text/plain"
+    XML = "application/xml"
+    CSV = "text/csv"
+    TSV = "text/tab-separated-values"
+    CSS = "text/css"
+    URI = "text/uri-list"
+    SVG = "image/svg+xml"
+    PNG = "image/png"
+    JSON = "application/json"
+    WEBM = "video/webm"
+    JPG = "image/jpeg"
+
+    def self.to_extension(content_type)
+      constants.detect { |const| const_get(const) == content_type }&.to_s&.downcase
+    end
+  end
+end

data/lib/allure_ruby_commons/model/executable_item.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+
+module Allure
+  class ExecutableItem < JSONable
+    # @param [Hash] options
+    # @option options [String] :name
+    # @option options [String] :description
+    # @option options [String] :description_html
+    # @option options [String] :stage ('scheduled'), {Allure::Stage}
+    # @option options [String] :status ('broken'), {Allure::Status}
+    # @option options [Allure::StatusDetails] :status_details
+    # @option options [Array<Allure::ExecutableItem>] :steps ([])
+    # @option options [Array<Allure::Attachment>] :attachments ([])
+    # @option options [Array<Allure::Parameter>] :parameters ([])
+    def initialize(**options)
+      @name = options[:name]
+      @description = options[:description]
+      @description_html = options[:description_html]
+      @status = options[:status] || Status::BROKEN
+      @status_details = options[:status_details] || StatusDetails.new
+      @stage = options[:stage] || Stage::SCHEDULED
+      @steps = options[:steps] || []
+      @attachments = options[:attachments] || []
+      @parameters = options[:parameters] || []
+    end
+
+    attr_accessor(
+      :name, :status, :status_details, :stage, :description, :description_html,
+      :steps, :attachments, :parameters, :start, :stop
+    )
+  end
+end

data/lib/allure_ruby_commons/model/fixture_result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Allure
+  class FixtureResult < ExecutableItem; end
+end

data/lib/allure_ruby_commons/model/jsonable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Allure
+  class JSONable
+    def as_json(_options = {})
+      instance_variables.each_with_object({}) do |var, map|
+        key = camelcase(var.to_s.delete_prefix("@"))
+        value = instance_variable_get(var)
+        map[key] = value unless value.nil?
+      end
+    end
+
+    def to_json(*options)
+      as_json(*options).to_json(*options)
+    end
+
+    def ==(other)
+      self.class == other.class && state == other.state
+    end
+
+    protected
+
+    def state
+      instance_variables.map { |var| instance_variable_get(var) }
+    end
+
+    private
+
+    def camelcase(str)
+      str = str.gsub(/(?:_+)([a-z])/) { Regexp.last_match(1).upcase }
+      str.gsub(/(\A|\s)([A-Z])/) { Regexp.last_match(1) + Regexp.last_match(2).downcase }
+    end
+  end
+end

data/lib/allure_ruby_commons/model/label.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+
+module Allure
+  class Label < JSONable
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    attr_accessor :name, :value
+  end
+end

data/lib/allure_ruby_commons/model/link.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+
+module Allure
+  class Link < JSONable
+    def initialize(type, name, url)
+      @type = type
+      @name = name
+      @url = url
+    end
+
+    attr_accessor :type, :name, :url
+  end
+end

data/lib/allure_ruby_commons/model/parameter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+
+module Allure
+  class Parameter < JSONable
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    attr_reader :name, :value
+  end
+end

data/lib/allure_ruby_commons/model/stage.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Allure
+  class Stage
+    SCHEDULED = "scheduled"
+    RUNNING = "running"
+    FINISHED = "finished"
+    INTERRUPTED = "interrupted"
+  end
+end

data/lib/allure_ruby_commons/model/status.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Allure
+  class Status
+    FAILED = :failed
+    BROKEN = :broken
+    PASSED = :passed
+    SKIPPED = :skipped
+  end
+end

data/lib/allure_ruby_commons/model/status_details.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Allure
+  class StatusDetails < JSONable
+    # @param [Boolean] known
+    # @param [Boolean] muted
+    # @param [Boolean] flaky
+    # @param [String] message
+    # @param [String] trace
+    def initialize(known: false, muted: false, flaky: false, message: nil, trace: nil)
+      @known = known
+      @muted = muted
+      @flaky = flaky
+      @message = message
+      @trace = trace
+    end
+
+    attr_accessor :known, :muted, :flaky, :message, :trace
+  end
+end

data/lib/allure_ruby_commons/model/step_result.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Allure
+  class StepResult < ExecutableItem; end
+end

data/lib/allure_ruby_commons/model/test_result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Allure
+  class TestResult < ExecutableItem
+    # @param [String] uuid
+    # @param [String] history_id
+    # @param [Hash] options
+    # @option options [String] :name
+    # @option options [String] :full_name
+    # @option options [String] :description
+    # @option options [String] :description_html
+    # @option options [String] :status ('broken')
+    # @option options [String] :stage ('scheduled')
+    # @option options [Allure::StatusDetails] :status_details
+    # @option options [Array<Allure::ExecutableItem>] :steps ([])
+    # @option options [Array<Allure::Label>] :labels ([])
+    # @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)
+      super
+      @uuid = uuid
+      @history_id = history_id
+      @full_name = options[:full_name] || "Unnamed"
+      @labels = options[:labels] || []
+      @links = options[:links] || []
+    end
+
+    attr_accessor :uuid, :history_id, :full_name, :labels, :links
+  end
+end

data/lib/allure_ruby_commons/model/test_result_container.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "jsonable"
+module Allure
+  class TestResultContainer < JSONable
+    def initialize(uuid: UUID.generate, name: "Unnamed")
+      @uuid = uuid
+      @name = name
+      @children = []
+      @befores = []
+      @afters = []
+      @links = []
+    end
+
+    attr_accessor :uuid, :name, :description, :description_html, :start, :stop, :children, :befores, :afters, :links
+  end
+end

data/lib/allure_ruby_commons/result_utils.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Allure
+  module ResultUtils
+    ISSUE_LINK_TYPE = "issue"
+    TMS_LINK_TYPE = "tms"
+
+    ALLURE_ID_LABEL_NAME = "AS_ID"
+    SUITE_LABEL_NAME = "suite"
+    PARENT_SUITE_LABEL_NAME = "parentSuite"
+    SUB_SUITE_LABEL_NAME = "subSuite"
+    EPIC_LABEL_NAME = "epic"
+    FEATURE_LABEL_NAME = "feature"
+    STORY_LABEL_NAME = "story"
+    SEVERITY_LABEL_NAME = "severity"
+    TAG_LABEL_NAME = "tag"
+    OWNER_LABEL_NAME = "owner"
+    LEAD_LABEL_NAME = "lead"
+    HOST_LABEL_NAME = "host"
+    THREAD_LABEL_NAME = "thread"
+    TEST_METHOD_LABEL_NAME = "testMethod"
+    TEST_CLASS_LABEL_NAME = "testClass"
+    PACKAGE_LABEL_NAME = "package"
+    FRAMEWORK_LABEL_NAME = "framework"
+    LANGUAGE_LABEL_NAME = "language"
+
+    class << self
+      # @param [Time] time
+      # @return [Number]
+      def timestamp(time = nil)
+        ((time || Time.now).to_f * 1000).to_i
+      end
+
+      # Current thread label
+      # @return [Allure::Label]
+      def thread_label
+        Label.new(THREAD_LABEL_NAME, Thread.current.object_id)
+      end
+
+      # Host label
+      # @return [Allure::Label]
+      def host_label
+        Label.new(HOST_LABEL_NAME, Socket.gethostname)
+      end
+
+      def language_label
+        Label.new(LANGUAGE_LABEL_NAME, "ruby")
+      end
+
+      def framework_label(value)
+        Label.new(FRAMEWORK_LABEL_NAME, value)
+      end
+
+      # Feature label
+      # @param [String] value
+      # @return [Allure::Label]
+      def feature_label(value)
+        Label.new(FEATURE_LABEL_NAME, value)
+      end
+
+      # Package label
+      # @param [String] value
+      # @return [Allure::Label]
+      def package_label(value)
+        Label.new(PACKAGE_LABEL_NAME, value)
+      end
+
+      # Suite label
+      # @param [String] value
+      # @return [Allure::Label]
+      def suite_label(value)
+        Label.new(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]
+      def test_class_label(value)
+        Label.new(TEST_CLASS_LABEL_NAME, value)
+      end
+
+      # Tag label
+      # @param [String] value
+      # @return [Allure::Label]
+      def tag_label(value)
+        Label.new(TAG_LABEL_NAME, value)
+      end
+
+      # Severity label
+      # @param [String] value
+      # @return [Allure::Label]
+      def severity_label(value)
+        Label.new(SEVERITY_LABEL_NAME, value)
+      end
+
+      # TMS link
+      # @param [String] value
+      # @return [Allure::Link]
+      def tms_link(value)
+        Link.new(TMS_LINK_TYPE, value, tms_url(value))
+      end
+
+      # Issue link
+      # @param [String] value
+      # @return [Allure::Link]
+      def issue_link(value)
+        Link.new(ISSUE_LINK_TYPE, value, issue_url(value))
+      end
+
+      # Get status based on exception type
+      # @param [Exception] exception
+      # @return [String]
+      def status(exception)
+        expectation_error?(exception) ? Status::FAILED : Status::BROKEN
+      end
+
+      # Get exception status detail
+      # @param [Exception] exception
+      # @return [Hash<Symbol, String>]
+      def status_details(exception)
+        StatusDetails.new(message: exception.message, trace: exception.backtrace&.join("\n"))
+      end
+
+      private
+
+      def tms_url(value)
+        Allure.configuration.link_tms_pattern.sub("{}", value)
+      end
+
+      def issue_url(value)
+        Allure.configuration.link_issue_pattern.sub("{}", value)
+      end
+
+      def expectation_error?(exception)
+        exception.instance_of?(RSpec::Expectations::ExpectationNotMetError) ||
+          exception.instance_of?(RSpec::Expectations::MultipleExpectationsNotMetError)
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/lib/allure_ruby_commons/util.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "zip"
+require "pathname"
+
+module Allure
+  class Util
+    ALLURE_CLI_VERSION = "2.10.0"
+    ALLURE_BIN_URL = "http://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/"\
+                      "#{ALLURE_CLI_VERSION}/allure-commandline-#{ALLURE_CLI_VERSION}.zip"
+
+    class << self
+      # Download allure bin if appropriate version is not in path
+      # @return [String] allure executable
+      def allure_cli
+        return "allure" if ALLURE_CLI_VERSION == `allure --version`.chomp
+
+        cli_dir = File.join(".allure", "allure-#{ALLURE_CLI_VERSION}")
+        zip = File.join(".allure", "allure.zip")
+        bin = File.join(cli_dir, "bin", "allure")
+
+        FileUtils.mkpath(".allure")
+        download_allure(zip) unless File.exist?(zip) || File.exist?(bin)
+        extract_allure(zip, ".allure") unless File.exist?(bin)
+
+        bin
+      end
+
+      private
+
+      def download_allure(destination)
+        File.open(destination, "w") { |file| file.write(open(ALLURE_BIN_URL).read) } # rubocop:disable Security/Open
+      end
+
+      def extract_allure(zip, destination)
+        Zip::File.foreach(zip) do |entry|
+          entry.restore_permissions = true
+          entry.extract(File.join(destination, entry.name))
+        end
+        FileUtils.rm(zip)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: allure-ruby-commons
+version: !ruby/object:Gem::Version
+  version: 2.10.0.beta2
+platform: ruby
+authors:
+- Andrejs Cunskis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Utilities allowing to implement allure result generation by other test
+  frameworks
+email: andrejs.cunskis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/allure-ruby-commons.rb
+- lib/allure_ruby_commons/allure_lifecycle.rb
+- lib/allure_ruby_commons/config.rb
+- lib/allure_ruby_commons/file_writer.rb
+- lib/allure_ruby_commons/model/attachment.rb
+- lib/allure_ruby_commons/model/content_type.rb
+- lib/allure_ruby_commons/model/executable_item.rb
+- lib/allure_ruby_commons/model/fixture_result.rb
+- lib/allure_ruby_commons/model/jsonable.rb
+- lib/allure_ruby_commons/model/label.rb
+- lib/allure_ruby_commons/model/link.rb
+- lib/allure_ruby_commons/model/parameter.rb
+- lib/allure_ruby_commons/model/stage.rb
+- lib/allure_ruby_commons/model/status.rb
+- lib/allure_ruby_commons/model/status_details.rb
+- lib/allure_ruby_commons/model/step_result.rb
+- 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/util.rb
+homepage: http://allure.qatools.ru
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Common library for allure results generation
+test_files: []