unobtainium-cucumber 0.1.0

data/features/status_actions.feature

@@ -0,0 +1,115 @@
+Feature:
+  Provide the ability to conveniently perform actions when a scenario finishes
+  and its status is known.
+
+  Background:
+    Given I have a test instance of the StatusActions module
+    Then I expect all configured actions to be present
+    And I want to clear configured actions
+
+  Scenario Outline: Function `#action_key`
+    Given I have a scenario which has <has_passed>
+    And the scenario <is_outline> an outline
+    Then I expect the output to contain <status> and <type>
+
+    Examples:
+      | has_passed | is_outline | status   | type      |
+      | passed     | is not     | :passed? | :scenario |
+      | failed     | is not     | :failed? | :scenario |
+      | passed     | is         | :passed? | :outline  |
+      | failed     | is         | :failed? | :outline  |
+
+  Scenario Outline: Function `#register_action` status
+    Given I try to register an action for status <status>
+    Then I expect the function to <succeed_or_fail>
+
+    Examples:
+      | status  | succeed_or_fail |
+      | passed? | succeed         |
+      | failed? | succeed         |
+      | passed  | fail            |
+      |         | fail            |
+
+  Scenario Outline: Function `#register_action` type option
+    Given I try to register an action for the type <type>
+    Then I expect the function to <succeed_or_fail>
+
+    Examples:
+      | type     | succeed_or_fail |
+      | scenario | succeed         |
+      | outline  | succeed         |
+      | other    | fail            |
+      |          | fail            |
+
+  Scenario: Try to register neither function nor block
+    Given I try to register no action
+    Then I expect the function to fail
+
+  Scenario: Try to register both function and block
+    Given I try to register two actions
+    Then I expect the function to fail
+
+  Scenario: No action, but options
+    Given I register no action, but provide options
+    Then I expect the there to be an error
+
+  Scenario: Invalid Hash action
+    Given I register a Hash as an action
+    Then I expect the there to be an error
+
+  Scenario: Multiple actions
+    Given I register an action
+    When I register another action
+    Then I expect there to be two registered actions
+
+  Scenario: No actions
+    Given I have registered no actions
+    Then I expect there to be no registered actions
+
+  Scenario: Action is executed
+    Given I have registered an action
+    Then I expect it to be executed
+
+  Scenario: Configured actions should be present
+    Given I register configured actions
+    Then I expect only configured actions to be present
+
+  Scenario: Execute method
+    Given I execute a method action
+    Then I expect this to succeed
+
+  Scenario: Execute block
+    Given I execute a block action
+    Then I expect this to succeed
+
+  Scenario: Execute symbol
+    Given I execute a symbol action
+    Then I expect this to succeed
+
+  Scenario: Execute string
+    Given I execute a string action
+    Then I expect this to succeed
+
+  Scenario: Execute namespaced string
+    Given I execute a namespaced string action
+    Then I expect this to succeed
+
+  Scenario: Execute dot-separated namespaced string
+    Given I execute a namespaced string action that is dot-separated
+    Then I expect this to succeed
+
+  Scenario: Execute non-resolving string
+    Given I execute string action that does not resolve
+    Then I expect this to fail
+
+  Scenario: Execute non-resolving symbol
+    Given I execute symbol action that does not resolve
+    Then I expect this to fail
+
+  Scenario: Execute non-resolving string with two dots
+    Given I execute string action with two dots
+    Then I expect this to fail
+
+  Scenario: Try to execute number
+    Given I execute a number action
+    Then I expect this to fail

data/features/step_definitions/action.rb

@@ -0,0 +1,61 @@
+# 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'
+require_relative './mocks/scenario'
+
+Given(/^I take a screenshot$/) do
+  ::Unobtainium::Cucumber::Action.store_screenshot(
+      self, MockScenario.new('screenshots')
+  )
+end
+
+Then(/^I expect there to be a matching screenshot file$/) do
+  # The expectation is that the file starts with an ISO8601 timestamp of today
+  # and ends in 'screenshots.png'. The part we can't be certain about is the
+  # exact time stamp, because seconds, minutes, etc. even years could have
+  # rolled over between taking the screenshot and finding it.
+
+  # So what we do instead is find files that match the end. If the start matches
+  # the syntax of a timestamp string, we can convert it to a timestamp. Then we
+  # can find out if between said timestamp and right now only a few seconds
+  # elapsed. If we find one such file, the test succeeds.
+  pattern = 'screenshots/*-screenshots.png'
+  timeout_match_files(pattern)
+
+  # *After* all checks, remove matching files.
+  FileUtils.rm(Dir.glob(pattern))
+end
+
+Given(/^I navigate to the best site in the world$/) do
+  driver.navigate.to 'http://finkhaeuser.de'
+end
+
+When(/^I capture the page content$/) do
+  # See the similar screnshot matching step for some details.
+  ::Unobtainium::Cucumber::Action.store_content(
+      self, MockScenario.new('contents')
+  )
+end
+
+Then(/^I expect there to be a matching content file$/) do
+  # See the similar screnshot matching step for some details.
+  pattern = 'content/*-contents.txt'
+  match_file = timeout_match_files(pattern)
+
+  # Check that some expected content exists.
+  match = File.open(match_file).grep(/<html/)
+  if match.empty?
+    raise "File content of '#{match_file}' does not seem to be valid HTML!"
+  end
+
+  # *After* all checks, remove matching files.
+  FileUtils.rm(Dir.glob(pattern))
+end

data/features/step_definitions/action_support.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.rb'
+require_relative './mocks/scenario'
+
+Given(/^I have a scenario named (.+)$/) do |scenario|
+  @action_support = {}
+  @action_support[:scenario] = MockScenario.new(scenario)
+end
+
+Given(/^I provide a tag (.+)$/) do |tag|
+  if tag == 'NIL'
+    tag = nil
+  end
+  @action_support[:tag] = tag
+end
+
+Given(/^the timestamp is (\d+\-\d+\-\d+T\d+:\d+:\d+Z)$/) do |timestamp|
+  @action_support[:timestamp] = timestamp
+end
+
+Then(/^I expect the filename to match (.+)/) do |expected|
+  expected = Regexp.new(expected)
+
+  tester = Class.new { extend ::Unobtainium::Cucumber::Action::Support }
+  result = tester.base_filename(@action_support[:scenario],
+                                @action_support[:tag],
+                                @action_support[:timestamp])
+
+  if not expected.match(result)
+    raise "Result '#{result}' did not match expectation #{expected}!"
+  end
+end

data/features/step_definitions/driver_reset.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+# rubocop:disable Style/GlobalVars
+$reset_called = 0
+
+def define_reset(the_driver = driver)
+  the_driver.class.class_eval do
+    def reset(*args)
+      $reset_called += 1
+      # rubocop:disable Lint/HandleExceptions
+      begin
+        super(*args)
+      rescue NoMethodError
+        # Work around drivers not supporting reset
+      end
+      # rubocop:enable Lint/HandleExceptions
+    end
+  end
+end
+
+def undefine_reset(the_driver = driver)
+  the_driver.class.class_eval do
+    # rubocop:disable Lint/HandleExceptions
+    begin
+      remove_method :reset
+    rescue NameError
+    end
+    # rubocop:enable Lint/HandleExceptions
+  end
+end
+
+Given(/^I remove any reset functions$/) do
+  undefine_reset
+end
+
+Given(/^I run a scenario to test driver reset$/) do
+  # We decorate the driver class with a 'reset' method for two reasons:
+  # a) we can this way track that it was called, and
+  # b) we work around the fact that not all drivers support the 'reset'
+  #    function.
+  define_reset
+end
+
+Then(/^the driver should be reset at the end$/) do
+  # Absolutely nothing to do here; but see $reset_called
+end
+
+Given(/^I run a scenario with a driver that knowns no reset$/) do
+  # Instanciate the driver by looking at its class.
+  driver.class
+end
+
+Then(/^the driver should not be reset at the end$/) do
+  # Absolutely nothing to do here; but see $reset_called
+end
+
+Given(/^I run a scenario with driver reset switched off$/) do
+  define_reset
+  # Note: enable this line, and $reset_called should be *zero* at the end.
+  # Testing this is really, really awkward.
+  # config['cucumber.driver_reset'] = false
+end
+
+at_exit do
+  # We expect reset to be called exactly twice, for the driver that defines
+  # such a function. But see the scenario for switching off driver reset
+  # above.
+  if not $reset_called >= 2
+    warn '*' * 80
+    warn "* If this fails, check the steps in 'driver_reset.feature'!"
+    warn "* We expected reset to be twice or more, but it got called "\
+      "#{$reset_called} times!"
+    warn '*' * 80
+    Kernel.exit(3)
+  end
+end
+
+# rubocop:enable Style/GlobalVars

data/features/step_definitions/extensions.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+Given(/^I register an extension with cucumber's World$/) do
+  # There's nothing to do here. The extension is registered in
+  # features/support/env.rb as it should be.
+end
+
+Then(/^I expect this extension to be used$/) do
+  # Calling the method should already fail, so no need for testing whether
+  # the method is callable :)
+  method_from_own_extension
+end

data/features/step_definitions/mocks/scenario.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+##
+# A mock scenario has a name
+class MockScenario
+  def initialize(name)
+    @name = name
+  end
+
+  attr_reader :name
+end

data/features/step_definitions/status_actions.rb

@@ -0,0 +1,358 @@
+# coding: utf-8
+#
+# unobtainium-cucumber
+# https://github.com/jfinkhaeuser/unobtainium-cucumber
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium-cucumber
+# contributors. All rights reserved.
+#
+
+# rubocop:disable Style/GlobalVars
+
+def dummy_action(*_); end
+
+def global_action(*_); end
+
+$counter = 0
+def counting_action(*_)
+  $counter += 1
+end
+
+def recording_action(_, scenario)
+  scenario.called = true
+end
+
+# TestModule
+module TestModule
+  def self.inner_recorder(*args)
+    recording_action(*args)
+  end
+end
+
+# StatusActionsTester doubles both as a test target for the actions, a
+# state crossing multiple step definitions, and behaving a bit like
+# a scenario.
+class StatusActionsTester
+  # Include StatusActions functionality...
+  include ::Unobtainium::Cucumber::StatusActions
+
+  # ... but also double as scenario
+  def passed?
+    return @passed
+  end
+
+  def outline?
+    return @outline
+  end
+
+  # Also, add setters for the above.
+  attr_writer :passed
+  attr_writer :outline
+
+  # Accessors for various test states
+  attr_accessor :register_status
+  attr_accessor :register_type
+  attr_accessor :register_functions
+
+  attr_accessor :exception
+
+  attr_accessor :called
+end
+
+Given(/^I have a test instance of the StatusActions module$/) do
+  @status_actions = StatusActionsTester.new
+end
+
+Then(/^I want to clear configured actions$/) do
+  @status_actions.clear_actions
+end
+
+Given(/^I have a scenario which has (passed|failed)$/) do |result|
+  @status_actions.passed = result == 'passed' ? true : false
+end
+
+Given(/^the scenario is( not)? an outline$/) do |negation|
+  @status_actions.outline = negation.nil? ? true : false
+end
+
+Then(
+  /^I expect the output to contain :(passed\?|failed\?) and :(scenario|outline)$/
+) do |status, type|
+  # Since the status action instance behaves as a scenario from the previous
+  # steps, we can pass it to the action_key method.
+  result = @status_actions.action_key(@status_actions)
+
+  expectation = [status.to_sym, type.to_sym]
+  if result != expectation
+    raise "Got '#{result}' but expected '#{expectation}'!"
+  end
+end
+
+Given(/^I try to register an action for status (.*)$/) do |status|
+  @status_actions.register_status = status.strip
+  @status_actions.register_type = :scenario # valid
+  @status_actions.register_functions = [:dummy_action, nil] # valid
+end
+
+Given(/^I try to register an action for the type (.*)$/) do |type|
+  @status_actions.register_status = :passed? # valid
+  @status_actions.register_type = type.strip
+  @status_actions.register_functions = [:dummy_action, nil] # valid
+end
+
+Given(/^I try to register no action$/) do
+  @status_actions.register_status = :passed? # valid
+  @status_actions.register_type = :scenario # valid
+  @status_actions.register_functions = [nil, nil]
+end
+
+Given(/^I try to register two actions$/) do
+  @status_actions.register_status = :passed? # valid
+  @status_actions.register_type = :scenario # valid
+  @status_actions.register_functions = [:dummy_action, proc { |*args| }]
+end
+
+Then(/^I expect the function to (.+)$/) do |result|
+  result.strip!
+
+  status_sym = @status_actions.register_status.to_sym
+  type_sym = @status_actions.register_type.to_sym
+  action_func = @status_actions.register_functions[0]
+  action_block = @status_actions.register_functions[1]
+
+  begin
+    @status_actions.register_action(status_sym, action_func, type: type_sym,
+                                    &action_block)
+  rescue RuntimeError => err
+    if result == 'succeed'
+      raise err
+    end
+  else
+    if result == 'fail'
+      raise "Expected this to fail, but it didn't!"
+    end
+  end
+end
+
+Given(/^I register no action, but provide options$/) do
+  # We'll perform the call, and record if there was an exception
+  begin
+    @status_actions.register_action(:passed?, type: :scenario)
+  rescue RuntimeError => err
+    @status_actions.exception = err
+  else
+    @status_actions.exception = nil
+  end
+end
+
+Given(/^I register a Hash as an action$/) do
+  # We'll perform the call, and record if there was an exception
+  begin
+    # Note that this is possible to do, but shouldn't happen. Normally
+    # if you pass a Hash as the second parmeter, you'd expect that to be
+    # the options, and a block to be provided.
+    @status_actions.register_action(:passed?, {}, {})
+  rescue RuntimeError => err
+    @status_actions.exception = err
+  else
+    @status_actions.exception = nil
+  end
+end
+
+Then(/^I expect the there to be an error$/) do
+  # Named differently from "the function to fail" because the above step would
+  # get far too complex.
+
+  # We expect an exception to be recorded, and if there is none, we fail
+  if @status_actions.exception.nil?
+    raise "Expected this to fail, but it didn't!"
+  end
+end
+
+Given(/^I register an action$/) do
+  @status_actions.register_action(:passed?, :dummy_action)
+end
+
+When(/^I register another action$/) do
+  @status_actions.register_action(:passed?) do |*args|
+  end
+end
+
+Then(/^I expect there to be two registered actions$/) do
+  # The default type is :scenario
+  registered = @status_actions.registered_actions(:passed?, :scenario)
+  if registered.length != 2
+    raise "Expected two registered actions, but found: #{registered.lenght}"
+  end
+end
+
+Given(/^I have registered no actions$/) do
+  # Not doing anything here!
+end
+
+Then(/^I expect there to be no registered actions$/) do
+  # The default type is :scenario
+  registered = @status_actions.registered_actions(:passed?, :scenario)
+  if not registered.empty?
+    raise "Expected zero registered actions, but found: #{registered.lenght}"
+  end
+end
+
+Given(/^I have registered an action$/) do
+  @status_actions.register_action(:passed?, :counting_action)
+end
+
+Then(/^I expect it to be executed$/) do
+  # Nothing to do; see at_exit below
+end
+
+Given(/^I register configured actions$/) do
+  # Configured actions should be registered automatically; that's hard to
+  # test here. However, see the background step!
+  # Let's just register them again!
+  register_config_actions(self)
+end
+
+Then(/^I expect all configured actions to be present$/) do
+  registered = @status_actions.registered_actions(:passed?, :scenario)
+  if not registered.include?('global_action')
+    raise "Expected 'global_action' in #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:passed?, :outline)
+  if not registered.include?('global_action')
+    raise "Expected 'global_action' in #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:failed?, :scenario)
+  if not registered.include?('method_from_own_extension')
+    raise "Expected 'global_action' in #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:failed?, :outline)
+  if not registered.include?('dummy_action')
+    raise "Expected 'global_action' in #{registered}!"
+  end
+end
+
+Then(/^I expect only configured actions to be present$/) do
+  registered = @status_actions.registered_actions(:passed?, :scenario)
+  if registered != %w(global_action)
+    raise "Expected different actions than #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:passed?, :outline)
+  if registered != %w(global_action)
+    raise "Expected different actions than #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:failed?, :scenario)
+  if registered != %w(method_from_own_extension)
+    raise "Expected different actions than #{registered}!"
+  end
+
+  registered = @status_actions.registered_actions(:failed?, :outline)
+  if registered != %w(dummy_action)
+    raise "Expected different actions than #{registered}!"
+  end
+end
+
+Given(/^I execute a method action$/) do
+  @status_actions.called = false
+  @status_actions.execute_action(self, method(:recording_action), @status_actions)
+end
+
+Then(/^I expect this to succeed$/) do
+  if not @status_actions.called
+    raise "Expected the action to be invoked, but it wasn't!"
+  end
+end
+
+Given(/^I execute a block action$/) do
+  action = proc do |_, scenario|
+    scenario.called = true
+  end
+
+  @status_actions.called = false
+  @status_actions.execute_action(self, action, @status_actions)
+end
+
+Given(/^I execute a symbol action$/) do
+  @status_actions.called = false
+  @status_actions.execute_action(self, :recording_action, @status_actions)
+end
+
+Given(/^I execute a string action$/) do
+  @status_actions.called = false
+  @status_actions.execute_action(self, 'recording_action', @status_actions)
+end
+
+Given(/^I execute a namespaced string action$/) do
+  @status_actions.called = false
+  @status_actions.execute_action(self, '::TestModule::inner_recorder',
+                                 @status_actions)
+end
+
+Given(/^I execute a namespaced string action that is dot\-separated$/) do
+  @status_actions.called = false
+  @status_actions.execute_action(self, '::TestModule.inner_recorder',
+                                 @status_actions)
+end
+
+Given(/^I execute string action that does not resolve$/) do
+  @status_actions.called = false
+  # rubocop:disable Lint/HandleExceptions
+  begin
+    @status_actions.execute_action(self, 'does not resolve', @status_actions)
+  rescue => _err
+  end
+  # rubocop:enable Lint/HandleExceptions
+end
+
+Given(/^I execute symbol action that does not resolve$/) do
+  @status_actions.called = false
+  # rubocop:disable Lint/HandleExceptions
+  begin
+    @status_actions.execute_action(self, :does_not_resolve, @status_actions)
+  rescue => _err
+  end
+  # rubocop:enable Lint/HandleExceptions
+end
+
+Given(/^I execute string action with two dots$/) do
+  @status_actions.called = false
+  # rubocop:disable Lint/HandleExceptions
+  begin
+    @status_actions.execute_action(self, 'can.not.resolve', @status_actions)
+  rescue => _err
+  end
+  # rubocop:enable Lint/HandleExceptions
+end
+
+Given(/^I execute a number action$/) do
+  @status_actions.called = false
+  # rubocop:disable Lint/HandleExceptions
+  begin
+    @status_actions.execute_action(self, 42, @status_actions)
+  rescue => _err
+  end
+  # rubocop:enable Lint/HandleExceptions
+end
+
+Then(/^I expect this to fail$/) do
+  if @status_actions.called
+    raise "Expected the action not to be invoked, but it was!"
+  end
+end
+
+at_exit do
+  # We expect the counting_action to be called once.
+  if not $counter >= 1
+    warn '*' * 80
+    warn "* If this fails, check the steps in 'status_actions.feature'!"
+    warn '*' * 80
+    Kernel.exit(4)
+  end
+end
+
+# rubocop:enable Style/GlobalVars