aruba 0.12.0 → 0.13.0

data/features/steps/core/announce.feature

@@ -201,3 +201,83 @@ Feature: Announce output during test run
     """
     $ export MY_VAR=my\ value\ \
     """
+
+  Scenario: Announce file system status of command
+    This will output information like owner, group, atime, mtime, ctime, size,
+    mode and if command is executable.
+
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    echo 'Hello World'
+    """
+    And a file named "features/exit_status.feature" with:
+    """cucumber
+    Feature: Announce
+      @announce-command-filesystem-status
+      Scenario: Run command
+        And I run `cli`
+        Then the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+    And the output should contain:
+    """
+    # mode       => 755
+    """
+    And the output should contain:
+    """
+    # owner
+    """
+    And the output should contain:
+    """
+    # group
+    """
+    And the output should contain:
+    """
+    # ctime
+    """
+    And the output should contain:
+    """
+    # mtime
+    """
+    And the output should contain:
+    """
+    # atime
+    """
+    And the output should contain:
+    """
+    # size
+    """
+    And the output should contain:
+    """
+    # executable
+    """
+
+  Scenario: Announce content of command
+    This will output the content of the executable command. Be careful doing
+    this with binary executables. This hook should be used with scripts only.
+
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    echo 'Hello World'
+    """
+    And a file named "features/exit_status.feature" with:
+    """cucumber
+    Feature: Announce
+      @announce-command-content
+      Scenario: Run command
+        And I run `cli`
+        Then the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+    And the output should contain:
+    """
+    #!/usr/bin/env bash
+
+    echo 'Hello World'
+    """

data/features/support/aruba.rb

@@ -1,6 +1,7 @@
 require 'aruba/cucumber'
 
 Aruba.configure do |config|
-  config.exit_timeout    = 120
-  config.io_wait_timeout = 2
+  config.exit_timeout                          = 120
+  config.io_wait_timeout                       = 2
+  config.activate_announcer_on_command_failure = [:stderr, :stdout, :command]
 end

data/lib/aruba/api/command.rb

@@ -168,14 +168,6 @@ module Aruba
         working_directory = expand_path('.')
         event_bus         = aruba.event_bus
 
-        aruba.announcer.announce(:full_environment, environment)
-        aruba.announcer.announce(:timeout, 'exit', exit_timeout)
-        aruba.announcer.announce(:timeout, 'io wait', io_wait_timeout)
-        aruba.announcer.announce(:wait_time, 'startup wait time', startup_wait_time)
-
-        aruba.announcer.announce(:directory, working_directory)
-        aruba.announcer.announce(:command, cmd)
-
         cmd = Aruba.platform.detect_ruby(cmd)
 
         mode = if Aruba.process
@@ -285,8 +277,13 @@ module Aruba
         end
 
         if fail_on_error
-          expect(command).to have_finished_in_time
-          expect(command).to be_successfully_executed
+          begin
+            expect(command).to have_finished_in_time
+            expect(command).to be_successfully_executed
+          rescue RSpec::Expectations::ExpectationNotMetError => e
+            aruba.announcer.activate(aruba.config.activate_announcer_on_command_failure)
+            raise e
+          end
         end
       end
       # rubocop:enable Metrics/CyclomaticComplexity

data/lib/aruba/colorizer.rb

@@ -0,0 +1,108 @@
+module Aruba
+  # The ANSIColor module can be used for namespacing and mixed into your own
+  # classes.
+  module AnsiColor
+    # :stopdoc:
+    ATTRIBUTES = [
+      [ :clear        ,   0 ],
+      [ :reset        ,   0 ],     # synonym for :clear
+      [ :bold         ,   1 ],
+      [ :dark         ,   2 ],
+      [ :italic       ,   3 ],     # not widely implemented
+      [ :underline    ,   4 ],
+      [ :underscore   ,   4 ],     # synonym for :underline
+      [ :blink        ,   5 ],
+      [ :rapid_blink  ,   6 ],     # not widely implemented
+      [ :negative     ,   7 ],     # no reverse because of String#reverse
+      [ :concealed    ,   8 ],
+      [ :strikethrough,   9 ],     # not widely implemented
+      [ :black        ,  30 ],
+      [ :red          ,  31 ],
+      [ :green        ,  32 ],
+      [ :yellow       ,  33 ],
+      [ :blue         ,  34 ],
+      [ :magenta      ,  35 ],
+      [ :cyan         ,  36 ],
+      [ :white        ,  37 ],
+      [ :on_black     ,  40 ],
+      [ :on_red       ,  41 ],
+      [ :on_green     ,  42 ],
+      [ :on_yellow    ,  43 ],
+      [ :on_blue      ,  44 ],
+      [ :on_magenta   ,  45 ],
+      [ :on_cyan      ,  46 ],
+      [ :on_white     ,  47 ]
+    ]
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+    # :startdoc:
+
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    def self.coloring?
+      @coloring
+    end
+
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
+    def self.coloring=(val)
+      @coloring = val
+    end
+    self.coloring = true
+
+    ATTRIBUTES.each do |c, v|
+      define_method(c) do |string|
+        result = ''
+        result << "\e[#{v}m" if Aruba::AnsiColor.coloring?
+        if block_given?
+          result << yield
+        elsif string
+          result << string
+        elsif respond_to?(:to_str)
+          result << to_str
+        else
+          return result #only switch on
+        end
+        result << "\e[0m" if Aruba::AnsiColor.coloring?
+        result
+      end
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+    def self.included(klass)
+      if klass == String
+        ATTRIBUTES.delete(:clear)
+        ATTRIBUTE_NAMES.delete(:clear)
+      end
+    end
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolored(string = nil) # :yields:
+      if block_given?
+        yield.gsub(COLORED_REGEXP, '')
+      elsif string
+        string.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all Aruba::Platforms::AnsiColor attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+  end
+end
+
+module Aruba
+  class Colorizer
+    include Aruba::AnsiColor
+  end
+end

data/lib/aruba/config.rb

@@ -26,9 +26,9 @@ module Aruba
     option_accessor :working_directory, :contract => { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath }, :default => 'tmp/aruba'
 
     if RUBY_VERSION < '1.9'
-      option_reader   :fixtures_path_prefix, :contract => { None => String }, :default => '%'
+      option_reader :fixtures_path_prefix, :contract => { None => String }, :default => '%'
     else
-      option_reader   :fixtures_path_prefix, :contract => { None => String }, :default => ?%
+      option_reader :fixtures_path_prefix, :contract => { None => String }, :default => ?%
     end
 
     option_accessor :exit_timeout, :contract => { Num => Num }, :default => 15
@@ -64,6 +64,8 @@ module Aruba
 
     option_accessor :physical_block_size, :contract => { Aruba::Contracts::IsPowerOfTwo => Aruba::Contracts::IsPowerOfTwo }, :default => 512
     option_accessor :console_history_file, :contract => { String => String }, :default => '~/.aruba_history'
+
+    option_accessor :activate_announcer_on_command_failure, :contract => { ArrayOf[Symbol] => ArrayOf[Symbol] }, :default => []
   end
 end
 

data/lib/aruba/cucumber/command.rb

@@ -1,6 +1,7 @@
 if Aruba::VERSION < '1.0.0'
   require 'aruba/cucumber/core'
 end
+require 'aruba/generators/script_file'
 
 When(/^I run "(.*)"$/)do |cmd|
   warn(%{\e[35m    The /^I run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
@@ -28,6 +29,17 @@ When(/^I successfully run `(.*?)`(?: for up to (\d+) seconds)?$/)do |cmd, secs|
   run_simple(cmd, :fail_on_error => true, :exit_timeout => secs && secs.to_i)
 end
 
+When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) do |shell, commands|
+  prepend_environment_variable('PATH', expand_path('bin') + ':')
+
+  Aruba.platform.mkdir(expand_path('bin'))
+  shell ||= Aruba.platform.default_shell
+
+  Aruba::ScriptFile.new(:interpreter => shell, :content => commands,
+                        :path => expand_path('bin/myscript')).call
+  step 'I run `myscript`'
+end
+
 When(/^I run "([^"]*)" interactively$/) do |cmd|
   Aruba.platform.deprecated(%{\e[35m    The /^I run "([^"]*)" interactively$/ step definition is deprecated. Please use the `backticks` version\e[0m})
 

data/lib/aruba/cucumber/hooks.rb

@@ -33,6 +33,14 @@ Before('@announce-command') do
   aruba.announcer.activate :command
 end
 
+Before('@announce-command-content') do
+  aruba.announcer.activate :command_content
+end
+
+Before('@announce-command-filesystem-status') do
+  aruba.announcer.activate :command_filesystem_status
+end
+
 Before('@announce-cmd') do
   Aruba.platform.deprecated 'The use of "@announce-cmd"-hook is deprecated. Please use "@announce-command"'
 
@@ -112,6 +120,8 @@ Before('@announce') do
   aruba.announcer.activate :stop_signal
   aruba.announcer.activate :timeout
   aruba.announcer.activate :wait_time
+  aruba.announcer.activate :command_content
+  aruba.announcer.activate :command_filesystem_status
 end
 
 Before('@debug') do

data/lib/aruba/errors.rb

@@ -28,4 +28,10 @@ module Aruba
   # Raised if command was already started, otherwise aruba forgets about the
   # previous pid and you've got hidden commands run
   class CommandAlreadyStartedError < Error; end
+
+  # Raised if an event name cannot be resolved
+  class EventNameResolveError < StandardError; end
+
+  # Raised if given object is not an event
+  class NoEventError < StandardError; end
 end

data/lib/aruba/event_bus.rb

@@ -0,0 +1,59 @@
+require 'aruba/event_bus/name_resolver'
+require 'aruba/errors'
+
+module Aruba
+  # Event bus
+  #
+  # Implements and in-process pub-sub events broadcaster allowing multiple observers
+  # to subscribe to different events that fire as your tests are executed.
+  #
+  class EventBus
+    # Create EventBus
+    #
+    # @param [#transform] resolver
+    #   A resolver which transforms Symbol, String, Class into an event Class.
+    def initialize(resolver)
+      @resolver = resolver
+      @handlers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Register for an event
+    #
+    # @param [String, Symbol, Class, Array] event_ids
+    #   If Array, register multiple events witht the same handler. If String,
+    #   Symbol, Class register handler for given event.
+    #
+    # @param [#call] handler_object
+    #   The handler object, needs to have method `#call`. Either
+    #   `handler_object` or `block` can be defined. The handler object gets the
+    #   event passed to `#call`.
+    #
+    # @yield
+    #   Handler block which gets the event passed as parameter.
+    def register(event_ids, handler_object = nil, &handler_proc)
+      handler = handler_proc || handler_object
+
+      fail ArgumentError, 'Please pass either an object#call or a handler block' if handler.nil? || !handler.respond_to?(:call)
+
+      Array(event_ids).flatten.each do |id|
+        @handlers[
+          @resolver.transform(id).to_s
+        ] << handler
+      end
+
+      nil
+    end
+
+    # Broadcast an event
+    #
+    # @param [Object] event
+    #   An object of registered event class. This object is passed to the event
+    #   handler.
+    #
+    def notify(event)
+      fail NoEventError, 'Please pass an event object, not a class' if event.is_a?(Class)
+
+      @handlers[event.class.to_s].each { |handler| handler.call(event) }
+    end
+  end
+end

data/lib/aruba/event_bus/name_resolver.rb

@@ -0,0 +1,168 @@
+require 'aruba/errors'
+
+# Event notification library
+module Aruba
+  # EventBus
+  class EventBus
+    # Resolve name to Event name
+    class NameResolver
+      # @private
+      # Helpers for Resolvers
+      module ResolveHelpers
+        def camel_case(underscored_name)
+          if RUBY_VERSION < '1.9.3'
+            underscored_name.to_s.split('_').map { |word| word.upcase.chars.to_a[0] + word.chars.to_a[1..-1].join }.join
+          else
+            underscored_name.to_s.split('_').map { |word| word.upcase[0] + word[1..-1] }.join
+          end
+        end
+
+        # Thanks ActiveSupport
+        # (Only needed to support Ruby 1.9.3 and JRuby)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(camel_cased_word) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+
+              if RUBY_VERSION < '1.9.3'
+                next candidate if constant.const_defined?(name)
+              else
+                next candidate if constant.const_defined?(name, false)
+              end
+
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              # rubocop:disable Style/EachWithObject
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+              # rubocop:enable Style/EachWithObject
+
+              # owner is in Object, so raise
+              constant.const_get(name, false)
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      # @private
+      # Convert a class in to an event class
+      class ClassResolver
+        class << self
+          def match?(event_id)
+            event_id.is_a? Class
+          end
+
+          # Which types are supported
+          def supports
+            [Class]
+          end
+        end
+
+        def transform(_, event_id)
+          event_id
+        end
+      end
+
+      # @private
+      # Convert a string in to an event class
+      class StringResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? String
+          end
+
+          # Which types are supported
+          def supports
+            [String]
+          end
+        end
+
+        def transform(_, event_id)
+          constantize(event_id)
+        end
+      end
+
+      # @private
+      # Convert a symbol in to an event class
+      class SymbolResolver
+        include ResolveHelpers
+
+        class << self
+          def match?(event_id)
+            event_id.is_a? Symbol
+          end
+
+          # Which types are supported
+          def supports
+            [Symbol]
+          end
+        end
+
+        def transform(default_namespace, event_id)
+          constantize("#{default_namespace}::#{camel_case(event_id)}")
+        end
+      end
+
+      # @private
+      # Default failing resolver
+      #
+      # This comes into play if the user passes an invalid event type
+      class FailingResolver
+        class << self
+          def match?(event_id)
+            fail ArgumentError, %(Input type "#{event_id.class}" of event_id "#{event_id}" is invalid)
+          end
+
+          def supports
+            []
+          end
+        end
+      end
+
+      protected
+
+      attr_reader :resolvers, :default_namespace
+
+      public
+
+      def initialize(default_namespace)
+        @default_namespace = default_namespace
+
+        @resolvers = []
+        @resolvers << ClassResolver
+        @resolvers << StringResolver
+        @resolvers << SymbolResolver
+        @resolvers << FailingResolver
+      end
+
+      def transform(event_id)
+        resolvers.find { |r| r.match? event_id }.new.transform(default_namespace, event_id)
+      rescue => e
+        # rubocop:disable Metrics/LineLength
+        raise EventNameResolveError, %(Transforming "#{event_id}" into an event class failed. Supported types are: #{@resolvers.map(&:supports).flatten.join(', ')}. #{e.message}.\n\n#{e.backtrace.join("\n")})
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+  end
+end