allure_turnip 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca1aa10aa83c24d6d56bc9f3e1888bc775de1b050a3c338951932e2d33d3cd8a
+  data.tar.gz: 76c304a7fe8836de50bfd89005d077ca0c31f5cd0496b6cbeeadfaa2ea730b97
+SHA512:
+  metadata.gz: 5ab5374519296e590373cd7582c50a3d2f6511e4e740489d09c62983d3bf43e56243c6b70488578fa51f6d0eaf34e08af1404422f795e47ccef021041b4746e3
+  data.tar.gz: 3688674f916a7b16d2517c09f6bcf57e52bbf3388c36c090ccec4261b6253aa23a157d6246cf09df1ceea9082b08a5d3732fe172ab8a637a53a9b451674f41f4

data/.gitignore

@@ -0,0 +1,15 @@
+*.class
+
+# Package Files #
+*.jar
+*.war
+*.ear
+*.gem
+
+allure-report
+target
+allure
+.idea
+*.iml
+*.ipr
+*.iws

data/.rspec

@@ -0,0 +1 @@
+-r turnip/rspec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    allure_turnip (0.1.0)
+      allure-ruby-adaptor-api (= 0.7.0)
+      rspec (~> 3.5)
+      turnip (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    allure-ruby-adaptor-api (0.7.0)
+      mimemagic
+      nokogiri (~> 1.7)
+      uuid
+    diff-lcs (1.3)
+    gherkin (5.1.0)
+    macaddr (1.7.1)
+      systemu (~> 2.6.2)
+    mimemagic (0.3.3)
+    mini_portile2 (2.4.0)
+    nokogiri (1.10.1)
+      mini_portile2 (~> 2.4.0)
+    rake (10.4.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    systemu (2.6.5)
+    turnip (3.1.0)
+      gherkin (~> 5.0)
+      rspec (>= 3.0, < 4.0)
+    uuid (2.3.9)
+      macaddr (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  allure_turnip!
+  bundler
+  rake
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -0,0 +1,68 @@
+# Allure Turnip
+
+[![Gem Version](https://badge.fury.io/rb/allure-rspec.svg)](http://badge.fury.io/rb/allure-rspec)
+
+Adaptor to use the Allure framework along with the [Turnip](https://github.com/jnicklas/turnip).
+
+## What's new
+
+See the [releases](https://github.com/aha-oretama/allure_turnip/releases) tab.
+
+
+## Setup
+
+Add the dependency to your Gemfile. Choose the version carefully:
+
+| Allure Turnip | Turnip |
+| ------------- | ------ |
+| >= 0.1.x | >= 3.0 |
+
+```ruby
+ gem 'allure_turnip'
+```
+
+And then include it in your spec_helper.rb:
+
+```ruby
+    require 'allure_turnip'
+
+    RSpec.configure do |c|
+      c.include AllureRSpec::Adaptor
+    end
+```
+
+## Advanced options
+
+You can specify the directory where the Allure test results will appear. By default it would be 'gen/allure-results'
+within your current directory.  
+When you add a `feature_with_filename` option, the suites of the the Allure test results include file's name as a prefix.  
+This options is useful if you have some same feature names. Because Allure overwrites the same feature name's result if there are some same feature names.
+
+```ruby
+    AllureRSpec.configure do |c|
+      c.output_dir = "/whatever/you/like" # default: gen/allure-results
+      c.clean_dir = false # clean the output directory first? (default: true)
+      c.logging_level = Logger::DEBUG # logging level (default: DEBUG)
+      c.feature_with_filename = true # default: false
+    end
+```
+
+## DSL
+In your *step* method, you can call `attach_file` method.
+The method attaches the file in the Allure result.
+
+## Usage examples
+
+**feature**
+```ruby
+Feature: Attach File
+  Scenario: This is an attaching file feature
+    Given attach file
+```
+
+**steps**
+```ruby
+step 'attach file' do
+  attach_file "test-file1", Tempfile.new("test")
+end
+```

data/allure_turnip.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "allure_turnip/version"
+
+Gem::Specification.new do |s|
+  s.name          = 'allure_turnip'
+  s.version       = AllureTurnip::Version::STRING
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ['aha-oretama']
+  s.email         = ['sekine_y_529@msn.com']
+  s.description   = %q{Adaptor to use Allure framework along with the Turnip}
+  s.summary       = "allure_turnip-#{AllureTurnip::Version::STRING}"
+  s.homepage      = 'https://github.com/aha-oretama/allure_turnip'
+  s.license       = 'Apache-2.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'rspec', '~> 3.5'
+  s.add_dependency 'allure-ruby-adaptor-api', '0.7.0'
+  s.add_dependency 'turnip', '~> 3.0'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+end

data/lib/allure_turnip.rb

@@ -0,0 +1,64 @@
+require 'allure-ruby-adaptor-api'
+require 'turnip'
+require 'allure_turnip/version'
+require 'allure_turnip/formatter'
+require 'allure_turnip/adaptor'
+require 'allure_turnip/dsl'
+require 'allure_turnip/hooks'
+require 'allure_turnip/turnip_extension'
+
+module AllureTurnip
+  module Config
+    class << self
+      attr_accessor :output_dir
+      attr_accessor :clean_dir
+      attr_accessor :logging_level
+      attr_accessor :feature_with_filename
+
+      DEFAULT_OUTPUT_DIR = 'gen/allure-results'
+      DEFAULT_LOGGING_LEVEL = Logger::DEBUG
+      DEFAULT_FEATURE_WITH_FILENAME = false
+
+      def output_dir
+        @output_dir || DEFAULT_OUTPUT_DIR
+      end
+
+      def clean_dir?
+        @clean_dir.nil? ? true : @clean_dir
+      end
+
+      def logging_level
+        @logging_level || DEFAULT_LOGGING_LEVEL
+      end
+
+      def feature_with_filename?
+        @feature_with_filename || DEFAULT_FEATURE_WITH_FILENAME
+      end
+    end
+  end
+
+  class Context
+    attr_accessor :rspec
+
+    def rspec
+      @rspec
+    end
+  end
+
+  class << self
+    def context
+      @context ||= Context.new
+    end
+  end
+
+  class << self
+    def configure(&block)
+      yield Config
+      AllureRubyAdaptorApi.configure { |c|
+        c.output_dir = Config.output_dir
+        c.logging_level = Config.logging_level
+      }
+    end
+  end
+
+end

data/lib/allure_turnip/adaptor.rb

@@ -0,0 +1,15 @@
+module AllureTurnip
+  module Adaptor
+    def self.included(base)
+      AllureTurnip.context.rspec = base
+      base.send :include, AllureTurnip::DSL
+      if RSpec::Core::Formatters::Loader.formatters.keys.find_all { |f| f == AllureTurnip::Formatter }.empty?
+        RSpec::Core::Formatters.register AllureTurnip::Formatter, *AllureTurnip::Formatter::NOTIFICATIONS
+        RSpec.configuration.add_formatter(AllureTurnip::Formatter)
+      end
+      RSpec::Core::ExampleGroup.send :include, AllureTurnip::Hooks
+      RSpec::Core::Example.send :include, AllureTurnip::DSL::Example
+    end
+  end
+end
+

data/lib/allure_turnip/dsl.rb

@@ -0,0 +1,73 @@
+require 'digest'
+require 'mimemagic'
+
+module AllureTurnip
+  module DSL
+    module Example
+
+      def current_step
+        if defined? @@__current_step
+          @@__current_step
+        else
+          nil
+        end
+      end
+
+      def allure_step(step, &block)
+        begin
+          AllureRubyAdaptorApi::Builder.start_step(__suite, __test, step)
+          __with_step step, &block
+          AllureRubyAdaptorApi::Builder.stop_step(__suite, __test, step)
+        rescue Exception => e
+          AllureRubyAdaptorApi::Builder.stop_step(__suite, __test, step, :failed)
+          raise e
+        end
+      end
+
+      def attach_file(title, file, opts = {})
+        step = current_step
+        AllureRubyAdaptorApi::Builder.add_attachment __suite, __test, opts.merge(:title => title, :file => file, :step => step)
+      end
+
+      private
+
+      def __suite
+        if AllureTurnip::Config.feature_with_filename?
+          "#{File.split(metadata[:example_group][:parent_example_group][:file_path])[1]} -> #{metadata[:example_group][:parent_example_group][:description]}"
+        else
+          metadata[:example_group][:parent_example_group][:description]
+        end
+      end
+
+      def __test
+        metadata[:example_group][:full_description]
+      end
+
+      def __description(data)
+        data[:full_description] || data[:description]
+      end
+
+      def __mutex
+        @@__mutex ||= Mutex.new
+      end
+
+      def __with_step(step, &block)
+        begin
+          locked = __mutex.try_lock
+          if locked
+            @@__current_step = step
+            AllureTurnip.context.rspec.hooks.send :run, :before, :step, self
+            yield self
+          end
+        ensure
+          if locked
+            AllureTurnip.context.rspec.hooks.send :run, :after, :step, self
+            @@__current_step = nil
+            __mutex.unlock
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/allure_turnip/formatter.rb

@@ -0,0 +1,143 @@
+require 'rspec/core' unless defined?(RSpec::Core)
+require 'rspec/core/formatters/base_formatter' unless defined?(RSpec::Core::Formatters::BaseFormatter)
+require 'fileutils'
+
+module AllureTurnip
+
+  class Formatter < RSpec::Core::Formatters::BaseFormatter
+
+    NOTIFICATIONS = [:example_group_started, :example_group_finished,
+                     :example_failed, :example_passed, :example_pending, :start, :stop]
+    ALLOWED_LABELS = [:feature, :story, :severity, :language, :framework, :issue, :testId, :host, :thread]
+
+    def example_failed(notification)
+      return unless turnip?(notification)
+
+      ex = notification.example.execution_result.exception
+      status = ex.is_a?(RSpec::Expectations::ExpectationNotMetError) ? :failed : :broken
+      formatter = RSpec.configuration.backtrace_formatter
+      formatter.exclusion_patterns.push /lib\/allure_turnip/
+      backtrace = formatter.format_backtrace(ex.backtrace, notification.example.metadata)
+      ex.set_backtrace(backtrace)
+      stop_test(notification.example, :exception => ex, :status => status)
+    end
+
+    def example_group_finished(notification)
+      return unless turnip?(notification)
+
+      if notification.group.examples.empty? # Feature has no examples
+        AllureRubyAdaptorApi::Builder.stop_suite(suite(notification.group))
+      end
+    end
+
+    def example_group_started(notification)
+      return unless turnip?(notification)
+
+      if notification.group.examples.empty? # Feature has no examples
+        AllureRubyAdaptorApi::Builder.start_suite(suite(notification.group), labels(notification))
+      else # Scenario has examples
+        suite = suite(notification.group)
+        test = test(notification.group)
+        AllureRubyAdaptorApi::Builder.start_test(suite, test, labels(notification))
+      end
+    end
+
+    def example_passed(notification)
+      return unless turnip?(notification)
+
+      stop_test(notification.example)
+    end
+
+    def example_pending(notification)
+      return unless turnip?(notification)
+
+      stop_test(notification.example)
+    end
+
+    def start(example_count)
+      dir = Pathname.new(AllureTurnip::Config.output_dir)
+      if AllureTurnip::Config.clean_dir?
+        puts "Cleaning output directory '#{dir}'..."
+        FileUtils.rm_rf(dir)
+      end
+      FileUtils.mkdir_p(dir)
+    end
+
+    def stop(notify)
+      AllureRubyAdaptorApi::Builder.build!
+    end
+
+    private
+
+    def turnip?(notification)
+      metadata(notification)[:turnip]
+    end
+
+    def stop_test(example, opts = {})
+      res = example.execution_result
+      AllureRubyAdaptorApi::Builder.stop_test(
+          suite(example.example_group),
+          test(example.example_group),
+          {
+              :status => res.status,
+              :finished_at => res.finished_at,
+              :started_at => res.started_at
+          }.merge(opts)
+      )
+    end
+
+    def suite(group)
+      if AllureTurnip::Config.feature_with_filename?
+        "#{File.split(group.parent_groups.last.metadata[:file_path])[1]} -> #{group.parent_groups.last.description}"
+      else
+        group.parent_groups.last.description
+      end
+    end
+
+    def test(group)
+      group.metadata[:full_description]
+    end
+
+    def metadata(example_or_group)
+      group?(example_or_group) ?
+          example_or_group.group.metadata :
+          example_or_group.example.metadata
+    end
+
+    def group?(example_or_group)
+      (example_or_group.respond_to? :group)
+    end
+
+    def labels(example_or_group)
+      labels = ALLOWED_LABELS.map { |label| [label, metadata(example_or_group)[label]] }.
+          find_all { |value| !value[1].nil? }.
+          inject({}) { |res, value| res.merge(value[0] => value[1]) }
+      detect_feature_story(labels, example_or_group)
+      labels
+    end
+
+    def method_or_key(metadata, key)
+      metadata.respond_to?(key) ? metadata.send(key) : metadata[key]
+    end
+
+    def detect_feature_story(labels, example_or_group)
+      metadata = metadata(example_or_group)
+      is_group = group?(example_or_group)
+      parent = (method_or_key(metadata, :parent_example_group))
+      if labels[:feature] === true
+        description = (!is_group && parent) ? method_or_key(parent, :description) : method_or_key(metadata, :description)
+        labels[:feature] = description
+        if labels[:story] === true
+          if parent
+            grandparent = parent && method_or_key(parent, :parent_example_group)
+            labels[:feature] = (!is_group && grandparent) ? method_or_key(grandparent, :description) :
+                method_or_key(parent, :description)
+          end
+          labels[:story] = description
+        end
+      end
+      labels
+    end
+
+  end
+end