unobtainium-cucumber 0.1.0

data/features/support/env.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+# Code coverage first
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'features'
+end
+
+# Other requires after SimpleCov
+require "unobtainium-cucumber"
+
+# Extensions used for testing
+module MyExtensions
+  def method_from_own_extension(*args, &block); end
+end # module MyExtensions
+
+World(MyExtensions)
+
+# Utility code for testing
+require_relative './utils'

data/features/support/utils.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+TIMESTAMP_REGEX ||= /\d{4}_\d{2}_\d{2}T\d{2}_\d{2}_\d{2}Z/
+
+##
+# Given a file name, extrat and convert timestamps
+def timestamp_from_filename(filename)
+  # First, check if we can find the file name matching a timestamp
+  parts = File.split(filename)
+  parts = parts[-1].split('-')
+  timestamp = parts[0]
+  if not TIMESTAMP_REGEX.match(timestamp)
+    return
+  end
+
+  # Great, then fix the formatting...
+  timestamp[4] = '-'
+  timestamp[7] = '-'
+  timestamp[13] = ':'
+  timestamp[16] = ':'
+
+  return Time.parse(timestamp)
+end
+
+##
+# Given a match pattern and optional timeout, finds files matching the pattern
+# that have been created within the given timeout from now.
+def timeout_match_files(pattern, timeout = 5)
+  now = Time.now.utc
+
+  Dir[pattern].each do |fname|
+    ts = timestamp_from_filename(fname)
+    if (now - ts).abs <= timeout
+      return fname
+    end
+  end
+
+  raise "No file matching '#{pattern}' with a timestamp in the last #{timeout} "\
+    "seconds was found!"
+end

data/lib/unobtainium-cucumber/action/content.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+require 'unobtainium-cucumber/action/support/naming'
+
+module Unobtainium
+  module Cucumber
+
+    ##
+    # Namespace for built-in status actions
+    module Action
+
+      class << self
+        include Support
+
+        ##
+        # Status action function that stores the page content (main page only)
+        def store_content(world, scenario)
+          # Make sure the content directory exists.
+          basedir = File.join(Dir.pwd, 'content')
+          FileUtils.mkdir_p(basedir)
+
+          # Store content. Note that not all drivers may support this.
+          filename = File.join(basedir, base_filename(scenario))
+          filename += '.txt'
+
+          File.open(filename, 'w') do |file|
+            file.write(world.driver.page_source)
+          end
+        end
+      end # class << self
+    end # module Action
+  end # module Cucumber
+end # module Unobtainium

data/lib/unobtainium-cucumber/action/screenshot.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+require 'unobtainium-cucumber/action/support/naming'
+
+module Unobtainium
+  module Cucumber
+
+    ##
+    # Namespace for built-in status actions
+    module Action
+
+      class << self
+        include Support
+
+        ##
+        # Status action function that takes a screenshot.
+        def store_screenshot(world, scenario)
+          # Make sure the screenshots directory exists.
+          basedir = File.join(Dir.pwd, 'screenshots')
+          FileUtils.mkdir_p(basedir)
+
+          # Take screenshot.
+          filename = File.join(basedir, base_filename(scenario))
+          filename += '.png'
+          world.driver.save_screenshot(filename)
+        end
+      end # class << self
+    end # module Action
+  end # module Cucumber
+end # module Unobtainium

data/lib/unobtainium-cucumber/action/support/naming.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+module Unobtainium
+  module Cucumber
+    module Action
+
+      ##
+      # Support functions for actions
+      module Support
+
+        ##
+        # Given a cucumber scenario, this function returns a timestamped
+        # base filename (without extension) that reflects parts of the scenario
+        # name.
+        # Note that the optional tag is not related to cucumber tags. It's just
+        # a way to distinguish two filenames for the same scenario at the same
+        # timestamp.
+        # We use '_' as a replacement for unrenderable characters, and
+        # '-' as a separator between file name components.
+        def base_filename(scenario, tag = nil, timestamp = nil)
+          # Build base name from parameters
+          require 'time'
+          timestamp ||= Time.now.utc.iso8601
+          timestamp.tr!('-', '_')
+          scenario_name = scenario.name
+          base_name = [timestamp, tag, scenario_name].reject(&:nil?).join('-')
+
+          # Make base name filename safe
+          base_name.gsub!(/^.*(\\|\/)/, '')
+          base_name.gsub!(/[^0-9A-Za-z.\-]+/, '_')
+
+          return base_name
+        end
+
+      end # module Support
+    end # module Action
+  end # module Cucumber
+end # module Unobtainium

data/lib/unobtainium-cucumber/driver_reset.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+After do |_|
+  if not driver.respond_to? :reset
+    next
+  end
+
+  # Covering this would require two separate test suites. I'm not sure I'm
+  # ready for that.
+  # :nocov:
+  if config['cucumber.driver_reset'] == false
+    next
+  end
+  # :nocov:
+
+  begin
+    driver.reset
+  rescue => error
+    # :nocov:
+    # If driver reset isn't possible, it doesn't make sense to continue
+    puts "DRIVER RESET WASN'T POSSIBLE DUE TO #{error} - BUT IS REQUIRED "\
+         "FOR BEFORE NEXT SCENARIO. WILL EXIT THE PROGRAM"
+    driver.quit
+    Kernel.exit(2)
+    # :nocov:
+  end
+end

data/lib/unobtainium-cucumber/status_actions.rb

@@ -0,0 +1,272 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+require 'unobtainium-cucumber/action/screenshot'
+require 'unobtainium-cucumber/action/content'
+
+module Unobtainium
+  module Cucumber
+    ##
+    # The StatusActions module contains all functionality for registering
+    # actions to be run when a scenario or outline ended with a particular
+    # status.
+    module StatusActions
+      # Key for storing actions in unobtainium's runtime instance.
+      RUNTIME_KEY = 'unobtainium-cucumber-status-actions'.freeze
+
+      # Default status actions
+      DEFAULTS = {
+        failed?: [
+          '::Unobtainium::Cucumber::Action.store_screenshot',
+        ]
+      }.freeze
+
+      ##
+      # Register a action for a :passed? or :failed? scenario.
+      # The :type parameter may either be :scenario or :outline.
+      # The action will be passed the matching scenario. If no
+      # explicit action is given, a block is also acceptable.
+      def register_action(status, action = nil, options = nil, &block)
+        # If the action is a Hash, then the options should be nil. If that's
+        # the case, we have no action and instead got passed options.
+        if action.is_a? Hash
+          if not options.nil?
+            raise "Can't pass a Hash as an action!"
+          end
+          options = action
+          action = nil
+        end
+
+        # Parameter checks!
+        if not [:passed?, :failed?].include?(status)
+          raise "Status may be one of :passed? or :failed? only!"
+        end
+
+        options ||= {}
+        type = options[:type] || :scenario
+        if not [:scenario, :outline].include?(type)
+          raise "The :type option may be one of :scenario or :outline only!"
+        end
+
+        if action.nil? and block.nil?
+          raise "Must provide either an action method or a block!"
+        end
+        if not action.nil? and not block.nil?
+          raise "Cannot provide both an action method and a block!"
+        end
+
+        callback = action || block
+
+        # The key to store callbacks under is comprised of the status
+        # and the type. That way we can match precisely when actions are to
+        # be executed.
+        key = [status, type]
+
+        # Retrieve existing actions
+        actions = {}
+        if ::Unobtainium::Runtime.instance.has?(RUNTIME_KEY)
+          actions = ::Unobtainium::Runtime.instance.fetch(RUNTIME_KEY)
+        end
+
+        # Add the callback
+        actions[key] ||= []
+        actions[key] |= [callback]
+
+        # And store the callback actions again.
+        ::Unobtainium::Runtime.instance.store(RUNTIME_KEY, actions)
+      end
+
+      ##
+      # For a given scenario, return the matching key for the actions.
+      def action_key(scenario)
+        return [
+          (scenario.passed? ? :passed? : :failed?),
+          (scenario.outline? ? :outline : :scenario)
+        ]
+      end
+
+      ##
+      # Automatically register all configured status actions.
+      # This is largely an internal function, run after the first scenario
+      # and before status actions are executed.
+      def register_config_actions(world)
+        to_register = world.config['cucumber.status_actions'] || DEFAULTS
+
+        [:passed?, :failed?].each do |status|
+          for_status = to_register[status]
+          if for_status.nil?
+            # :nocov:
+            next
+            # :nocov:
+          end
+
+          # If the entry for the status is an Array, it applies to scenarios
+          # and outlines equally. Otherwise we'll have to find a Hash with
+          # entries for either or both.
+          actions = {}
+          if for_status.is_a?(Array)
+            actions[:scenario] = for_status
+            actions[:outline] = for_status
+          elsif for_status.is_a?(Hash)
+            actions[:scenario] = for_status[:scenario] || []
+            actions[:outline] = for_status[:outline] || []
+          else
+            # :nocov:
+            raise "Cannot interpret status action configuration for status "\
+              "#{status}; it should be an Array or Hash, but instead it was"\
+              " this: #{for_status}"
+            # :nocov:
+          end
+
+          # Now we have actions for the statuses, we can register them.
+          [:scenario, :outline].each do |type|
+            actions[type].each do |action|
+              register_action(status, action, type: type)
+            end
+          end
+        end
+      end
+
+      ##
+      # Given an action and a scenario, execute the action. This includes
+      # late/lazy resolution of String or Symbol actions.
+      def execute_action(world, action, scenario)
+        # Simplest case first: the action is already callable.
+        if action.respond_to?(:call)
+          return action.call(world, scenario)
+        end
+
+        # Symbols are almost as easy to handle: they must resolve to a
+        # method, either globally or on the world object.
+        if action.is_a? Symbol
+          meth = resolve_action(Object, world, action)
+          if meth.nil?
+            raise NoMethodError, "Symbol :#{action} could not be resolved "\
+              "either globally or as part of the cucumber World object, "\
+              "aborting!"
+          end
+          return meth.call(world, scenario)
+        end
+
+        # At this point, the action better be a String.
+        if not action.is_a? String
+          raise "Action '#{action}' is not callable, and not a method name. "\
+            "Aborting!"
+        end
+
+        # Split module and method name
+        module_name, method_name = split_string_action(action)
+
+        # If we have no discernable module, use Object instead.
+        the_module = Object
+        if not module_name.nil? and not module_name.empty?
+          the_module = Object.const_get(module_name)
+        end
+
+        # Try the module we found (i.e. possibly Object) and world for
+        # resolving the method name.
+        meth = resolve_action(the_module, world, method_name)
+        if meth.nil?
+          raise NoMethodError, "Action '#{action}' could not be resolved!"
+        end
+
+        return meth.call(world, scenario)
+      end
+
+      ##
+      # For a given status and type, return the registered actions.
+      def registered_actions(status, type)
+        if not ::Unobtainium::Runtime.instance.has?(RUNTIME_KEY)
+          return []
+        end
+
+        actions = ::Unobtainium::Runtime.instance.fetch(RUNTIME_KEY)
+        return actions[[status, type]] || []
+      end
+
+      ##
+      # Partially for testing purposes, clears the action registry.
+      def clear_actions
+        if not ::Unobtainium::Runtime.instance.has?(RUNTIME_KEY)
+          # :nocov:
+          return
+          # :nocov:
+        end
+
+        ::Unobtainium::Runtime.instance.delete(RUNTIME_KEY)
+      end
+
+      ##
+      # Resolves the given symbol in either of the given namespace or the
+      # world object. Returns nil if neither contained the symbol.
+      def resolve_action(namespace, world, method_name)
+        method_sym = method_name.to_sym
+
+        [namespace, world].each do |receiver|
+          begin
+            return receiver.method(method_sym)
+          rescue NameError
+            next
+          end
+        end
+        return nil
+      end
+
+      ##
+      # Splits a string action into a module prefix and a method name
+      def split_string_action(action)
+        # Try to see whether we have a fully qualified name that requires us
+        # to query a particular module for the method.
+        split_action = action.split(/::/)
+        method_name = split_action.pop
+
+        # If the method name contains a dot, it uses 'Module.method' notation.
+        # rubocop:disable Lint/EmptyWhen
+        split_method = method_name.split(/\./)
+        case split_method.length
+        when 1
+          # Do nothing; the method name did not contain a dot
+        when 2
+          # We have a method name and a module part
+          split_action << split_method[0]
+          method_name = split_method[1]
+        else
+          raise "Too many dots in method name: #{method_name}"
+        end
+        # rubocop:enable Lint/EmptyWhen
+
+        # Re-join the module name
+        module_name = split_action.join('::')
+
+        return module_name, method_name
+      end
+    end # module StatusActions
+  end # module Cucumber
+end # module Unobtainium
+
+##
+# In the Before hook, we register configured actions.
+Before do |_|
+  # Register all configured actions.
+  register_config_actions(self)
+end
+
+##
+# The After hook with cucumber defined here will execute all matching,
+# registered actions.
+After do |scenario|
+  # Fetch actions applying to this scenario
+  key = action_key(scenario)
+  applicable_actions = registered_actions(key[0], key[1])
+
+  # Execute all actions applying to this scenario
+  applicable_actions.each do |action|
+    execute_action(self, action, scenario)
+  end
+end

data/lib/unobtainium-cucumber/version.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+module Unobtainium
+  module Cucumber
+    # The current release version
+    VERSION = "0.1.0".freeze
+  end # module Cucumber
+end # module Unobtainium

data/lib/unobtainium-cucumber.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+require 'unobtainium'
+require 'unobtainium-cucumber/version'
+
+# First things first: extend the World. Otherwise nothing in this file will
+# work.
+World(Unobtainium::World)
+
+require 'unobtainium-cucumber/driver_reset.rb'
+require 'unobtainium-cucumber/status_actions.rb'
+
+World(Unobtainium::Cucumber::StatusActions)

data/unobtainium-cucumber.gemspec

@@ -0,0 +1,54 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unobtainium-cucumber/version'
+
+# rubocop:disable Style/UnneededPercentQ, Style/ExtraSpacing
+# rubocop:disable Style/SpaceAroundOperators
+# rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |spec|
+  spec.name          = "unobtainium-cucumber"
+  spec.version       = Unobtainium::Cucumber::VERSION
+  spec.authors       = ["Jens Finkhaeuser"]
+  spec.email         = ["jens@finkhaeuser.de"]
+  spec.description   = %q(
+    The unobtainium-cucucmber gem adds some convenient cucumber specific hooks
+    for use with unobtainium.
+  )
+  spec.summary       = %q(
+    Cucumber hooks for unobtainium.
+  )
+  spec.homepage      = "https://github.com/jfinkhaeuser/unobtainium-cucumber"
+  spec.license       = "MITNFA"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rubocop", "~> 0.46"
+  spec.add_development_dependency "rake", "~> 11.2"
+  spec.add_development_dependency "simplecov", "~> 0.12"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "appium_lib"
+  spec.add_development_dependency "selenium-webdriver"
+  spec.add_development_dependency "chromedriver-helper"
+  spec.add_development_dependency "phantomjs"
+
+  spec.add_dependency "unobtainium", "~> 0.10"
+  spec.add_dependency "cucumber", "~> 2.0"
+end
+# rubocop:enable Metrics/BlockLength
+# rubocop:enable Style/SpaceAroundOperators
+# rubocop:enable Style/UnneededPercentQ, Style/ExtraSpacing