aruba-jbb 0.2.6.8 → 0.2.6.9

data/History.txt

@@ -1,10 +1,15 @@
+== 0.2.6.9 jbb
+* added timeout method and basic support step definitions
+* somewhat improved api documentation
+
 == 0.2.6.8 jbb
 * added some api method documentation
 
 == 0.2.6.7 msassak
+* Returned to using Background_Process
 
 === Bug fixes
-* Outputting large amounts of data causes BackgroundProcess#exitstatus to hang (#18 Mike Sassak)
+* Outputting large amounts of data causes BackgroundProcess to hang
 
 == 0.2.6.6 jbb
 * reverted run api method to old implementation and removed background_process

data/README.rdoc

@@ -1,7 +1,7 @@
 = Aruba
 
 Aruba-jbb is a fork of http://github.com/aslakhellesoy/aruba and is found
-at http://byrnejb/aruba.
+at http://github.com/byrnejb/aruba.
 
 Aruba-jbb is a set of api methods and cucumber steps for driving out command
 line application behaviours. The command line application can be anything,
@@ -28,9 +28,13 @@ permits switching between the two in Bundler without having to alter env.rb
 as well.  However, as of v-0.2.6.3 you have the option of requiring
 <tt>aruba_jbb</tt> instead.
 
-You now have a bunch of step definitions that you can use in your features. 
-Look at aruba/cucumber_steps.rb to see all the step definitions. Look at 
+You now have sever api mehtods and a selection of step definitions that
+you can use in features that test stand-alone processes.  Look at 
+aruba/cucumber_steps.rb to see all the step definitions. Look at 
 features/*.feature for examples (which are also testing Aruba itself).
+A start has been made at  documenting the api as well.  Any suggestions
+to improve what is already there, or to provide whatever is missing, are
+most welcome.
 
 You should be aware that Aruba runs the application it tests and creates
 all local output in its own working directory (awd). The awd defaults to
@@ -70,14 +74,28 @@ Upstream addressed the more limited problem of locating <code>./bin</code>
 by adding a <code>@bin</code> tag which appends <code>./bin</code> to Cucumber's
 LOADPATH. This technique is supported by Aruba-jbb as well.
 
+The aruba <tt>run</tt> api method is now (0.2.6.9) surrounded by a timeout call.
+This means that after the default period of 2 seconds any process under test
+is forceably terminated.  However, be advised that the run api methods raises 
+no error is raised by default.Instead the process exit status is set to -1 and
+stderr will contain <em>Aruba::Api::ProcessTimeout: execution expired</em>.  
+You are therefore advised to either override the When /run "([^\"])"/ do |cmd|
+step definition or provide an alternative form.
 
-== Ruby/RVM love
+The default timeout value of 2 may be overriden either by defining an environmental
+variable called ARUBA_RUN_TIMEOUT to the approprate value (in seconds) or by
+passing an optional third parameter to the run api method.  Fractional values
+are acepted but granularity of less than interger seconds is not guarenteed to
+work. 
 
-Aruba once had a couple of step definitions to make it easier to test your 
-Ruby command line program with specific versions of Ruby (regardless of 
-what Ruby version you were using to invoke Cucumber).  These were removed in 
-upstream's 0.2.2 version and are no longer present in this fork either.
-The last version of this fork having them was 0.2.6.
+Timeout does not work for the run_interactive api method. This is experimaental
+code merged from Mike Sassak's fork.
+
+== Ruby/RVM
+
+Aruba once had api methods to run rvm ruby from inside aruba. These
+were removed in upstream's 0.2.2 version and are no longer present in this
+fork either. The last version of this fork having them was 0.2.6.
 
 To test against specific versions of Ruby using RVM you are advised to use
 following idiom (note the comma between Ruby version numbers):

data/aruba-jbb.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{aruba-jbb}
-  s.version = "0.2.6.8"
+  s.version = "0.2.6.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aslak Hellesøy", "David Chelimsky", "James B. Byrne", "Mike Sassak"]

data/features/flushing.feature

@@ -11,15 +11,15 @@ Feature: Flushing output
     Then the stdout should contain "rword"
 
 
-  Scenario: Tons of output
+  Scenario: Stdout should equal output length plus \n
     When I run "ruby -e 'puts :a.to_s * 65536'"
     Then the output should contain "a"
-    And the output should be 65537 bytes long
+    And the output should be exactly "65537" bytes long
 
-
-  Scenario: Tons of interactive output
+  
+  Scenario: Interactive Stdout should equal output length plus \n
     When I run "ruby -e 'len = gets.chomp; puts :a.to_s * len.to_i'" interactively
     And I type "65536"
     Then the output should contain "a"
-    And the output should be 65537 bytes long
+    And the output should be at least "65536" bytes long
 

data/features/output.feature

@@ -38,6 +38,7 @@ Feature: Output
       good-bye
       """
 
+  @announce
   Scenario: Detect exact one-line output
     When I run "ruby -e 'puts \"hello world\"'"
     Then the output should contain exactly "hello world\n"

data/features/process_timeout.feature

@@ -0,0 +1,25 @@
+Feature: process should timeout
+
+  In order to prevent test runs from suspending indefinitiely
+  As a developer using Cucumber Aruba
+  I want long processes to terminate after a fixed elapsed time
+
+  
+  Scenario: process runner times out for long process
+    When I run "ruby -e 'sleep(12)'"
+    Then the exit status should not be 0
+      And stderr should contain "execution expired"
+
+  
+  Scenario: process runner timeout can be set lower than default
+    Given the following step should fail with RuntimeError:
+      """
+      When I run "ruby -e 'sleep(2)'" with timeout of "1.5" seconds
+      """
+    Then the exit status should be -1 
+
+  
+  Scenario: process runner timeout can be set higher than default
+    When I run "ruby -e 'sleep(4)'" with timeout of "5.7" seconds
+    Then the exit status should be 0
+      And stderr should be empty

data/features/step_definitions/aruba_dev_steps.rb

@@ -74,10 +74,19 @@ When /^aruba should fail with "([^\"]*)"$/ do |error_message|
 end
 
 
+When /^the following step should fail with RuntimeError:$/ do |multiline_step|
+  proc {steps multiline_step}.should raise_error(RuntimeError)
+end
+
+
 When /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
   proc {steps multiline_step}.should raise_error(RSpec::Expectations::ExpectationNotMetError)
 end
 
-Then /^the output should be (\d+) bytes long$/ do |length|
+Then /^the output should be at least "(\d+)" bytes long$/ do |length|
+  combined_output.length.should >= length.to_i 
+end
+
+Then /^the output should be exactly "(\d+)" bytes long$/ do |length|
   combined_output.length.should == length.to_i 
 end

data/lib/aruba/api.rb

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'tempfile'
 require 'rbconfig'
 require 'background_process'
@@ -6,7 +7,7 @@ module Aruba
   module Api
 
     # announce_or_puts(msg) is an internal helper method for
-    # reproduccing test process output in the Aruba run.
+    # reproducing test process output in the Aruba run.
     #
     def announce_or_puts(msg)
       if(@puts)
@@ -32,7 +33,7 @@ module Aruba
       end
     end
 
-    # aruba_working_dir simple returns the value of the current
+    # aruba_working_dir simply returns the value of the current
     # directory that aruba is running its features in. This is
     # set using the aruba_working_dir_set method from within the
     # step definitions or through the environment variable
@@ -80,8 +81,8 @@ module Aruba
       end
     end
 
-    # assert_exit_status_and_partial_output(pass_or_fail, output) is an
-    # internal helper method not really should not be used in a step definition.
+    # assert_exit_status_and_partial_output is an internal helper
+    # method that really should not be used in a step definition.
     #
     def assert_exit_status_and_partial_output(expect_to_pass, partial_output)
       assert_partial_output(partial_output)
@@ -92,22 +93,45 @@ module Aruba
       end
     end
 
-    # assert_failing_with(output) uses assert_exit_status_and_partial_output.
+    # assert_failing_with uses assert_exit_status_and_partial_output.
     # It passes the exit status expectation as false (fail) and the text
     # expected in the output to that method.
     #
+    # Usage:
+    #   Then the program should fail with:
+    #   """
+    #   No such entry
+    #   """
+    #
+    #   Then /the program should fail with:$/ do |content|
+    #     assert_failing_with(content)
+    #
     def assert_failing_with(partial_output)
       assert_exit_status_and_partial_output(false, partial_output)
     end
 
-    # assert_partial_output(partial_output)
+    # assert_partial_output test if the provided string or rexexo occurs
+    # in either $stdout or $stderr.
+    #
+    # Usage:
+    #   Then I should see "this text" in the output
+    #
+    #   Then /I should see "([^\"]*)" in the output/ do |content\
+    #     assert_partial_output(content)
+    #
     def assert_partial_output(partial_output)
       combined_output.should =~ regexp(partial_output)
     end
 
-    # assert_passing_with(output) uses assert_exit_status_and_partial_output.
+    # assert_passing_with uses assert_exit_status_and_partial_output.
     # It passes the exit status expectation as true (pass) and the text
-    # expected in the output to that method.
+    # expected in the output to that method. See assert_failing_with.
+    #
+    # Usage:
+    #   Then the program should run successfully with ""
+    #
+    #   Then /the program should run successfully with "([^\"]*)"/ do |output|
+    #     assert_passing_with(output)
     #
     def assert_passing_with(partial_output)
       assert_exit_status_and_partial_output(true, partial_output)
@@ -116,7 +140,10 @@ module Aruba
     # cd(path) changes aruba's working directory (awd) to path. 
     #
     # Usage:
-    #   When I cd to "foo/nonexistant" step"
+    #   When I cd to "foo/nonexistant"
+    #
+    #   When /I cd to "([^\"]*)"/ do |dir|
+    #     cd(dir)
     #
     def cd(dir)
       dirs << dir
@@ -134,6 +161,14 @@ module Aruba
     #     | foo/bar |
     #     | foo/bla |
     #
+    #   Then the following directories should not exist:
+    #     | bar/foo |
+    #     | bar/none |
+    #
+    #   When /following directories should exist:$/ do |directories|
+    #     check_directory_presence(directories.raw.map{
+    #       |directory_row| directory_row[0]}, true)
+    #
     def check_directory_presence(paths, expect_presence)
       in_current_dir do
         paths.each do |path|
@@ -146,8 +181,8 @@ module Aruba
       end
     end
 
-    # check_exact_file_content(file, exact_content) veries that
-    # the specified file contains exactly the provided text.
+    # check_exact_file_content veries that the specified file contains
+    # exactly the provided text.
     #
     # Usage:
     #   Then the file "foo" should contain exactly:
@@ -156,9 +191,12 @@ module Aruba
     #     And this
     #     """
     #
-    def check_exact_file_content(file, exact_content)
+    #   When /the file "([^\"]*)" should contain exactly:$/ do |file,contents|
+    #     check_exact_file_content(exact_output)
+    #
+    def check_exact_file_content(file, contents)
       in_current_dir do
-        IO.read(file).should == exact_content
+        IO.read(file).should == contents
       end
     end
 
@@ -166,7 +204,20 @@ module Aruba
     # the specified file contains at least the provided text.
     #
     # Usage:
-    #   Then I do have the file named "foo" with "blah"
+    #   Then the file named "foo" should contain:
+    #     """
+    #     My file should have this.
+    #     And this
+    #     """
+    #
+    #   Then the file "foo" should not contain:
+    #     """
+    #     My file should not have this.
+    #     And this
+    #     """
+    #
+    #   When /the file named "foo" should contain:$/ do |file, content|
+    #     check_file_content(file, content, true)
     #
     def check_file_content(file, partial_content, expect_match)
       regexp = regexp(partial_content)
@@ -180,10 +231,20 @@ module Aruba
       end
     end
 
-    # check_file_presence(paths, expect_presence) operates on files in
-    # a fashion similare to check_directory_presence.  it enumerates
-    # of a collection fo file names and passes or fails on the
-    # existance of each according to the expect_presence setting.
+    # check_file_presence operates on files in a fashion similar
+    # to check_directory_presence.  it enumerates on a collection
+    # of file names and passes or fails on the first presence or
+    # abscence in the filesystem according to the expect_presence setting.
+    #
+    # Usage:
+    #   When the following files should exist:
+    #   """
+    #   blah/file.tst
+    #   bare/file1.test
+    #   foor/barnet.tst
+    #   """
+    #   When /following files? should exist:$/ do |files|
+    #     check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
     #
     def check_file_presence(paths, expect_presence)
       in_current_dir do
@@ -197,9 +258,9 @@ module Aruba
       end
     end
   
-    # clean_up(dir = current_dir) is an internal helper method that empties
-    # the current working directory of all content. It is used in the 
-    # Aruba before hook to clear out the awd at the start of each scenario.
+    # clean_up is an internal helper method that empties the current working
+    # directory of all content. It is used in the  Aruba before hook to clear
+    # out the awd at the start of each scenario.
     #
     # It will not clear any directory that does not contain the directory
     # <tt>/tmp/</tt> somewhare in its path.
@@ -214,8 +275,8 @@ module Aruba
       end
     end
 
-    # clean_up!(dir = current_dir).  Internal helper method.  Does not check
-    # for tmp directory path.
+    # clean_up! is an Internal helper method that clears the awd without
+    # checking for tmp in the directory path.  Do not use this.
     #
     def clean_up!(dir = current_dir)
       FileUtils.rm_rf(dir)
@@ -225,29 +286,65 @@ module Aruba
     # combined_output is an internal helper methiod that concatenates the
     # contents of $stdout with $stderr.
     #
+    # Usage:
+    #   Then output should contain:
+    #     """
+    #     toto
+    #     red shoes
+    #     """
+    #   Then output should contain "toto"
+    #   Then output should contain exactly:
+    #     """
+    #     toto
+    #     red shoes
+    #     """
+    #   Then output should contain exactly "toto"
+    #   Then output should not contain:
+    #     """
+    #     toto
+    #     red shoes
+    #     """
+    #   Then output should not contain "toto"
+    #   Then output should not contain exactly:
+    #     """
+    #     toto
+    #     red shoes
+    #     """
+    #   Then output should not contain exactly "toto"
+    #   
+    #   When /output should contain "([^\"]*)"$/ do |partial_output|
+    #     combined_output.should =~ regexp(partial_output)
+    #
     def combined_output
       if @interactive
-        interactive_output
+        interactive_output.to_s
       else
-        @last_stdout.to_s + @last_stderr.to_s
+        if @last_stderr != nil and @last_stderr != ""
+          @last_stdout.to_s + @last_stderr.inspect.to_s
+        else
+          @last_stdout.to_s
+        end
       end
     end
 
-    # create_dir(dir_name) creates the given directory name within the awd
+    # create_dir creates the given directory name within the awd
     # subject to normal filesystem restrictions.
     # 
     # `Usage:
     #   Given I do have a directory named "foobar"$
     #
+    #   When /I do have a directory named "([^\"]*)"$/ do |dir_name|
+    #     create_dir(dir_name)
+    #
     def create_dir(dir_name)
       in_current_dir do
         _mkdir(dir_name)
       end
     end
 
-    # create_file(file_name, file_content, check_presence = false) creates
-    # the given file name in the awd and fills it with the provided content,
-    # optionally checking first to see if the file exists.
+    # create_file creates the given file name in the awd and fills it
+    # with the provided content, optionally checking first to see if 
+    # the file exists.
     #
     # Usage:
     #   When we do have a file named "foo" containing:
@@ -255,7 +352,15 @@ module Aruba
     #     This is in my new file.
     #     And so is this
     #     """
-    #     
+    #
+    #   When /do have a file named "([^\"]*)" containing:$/ do |file, content|
+    #     create_file(file, content)
+    #
+    #   When I do have an empty file named "empty"
+    #
+    #   When /I do have an empty file named "([^\"]*)"$/ do |file_name|
+    #     create_file(file_name, "")
+    #   
     def create_file(file_name, file_content, check_presence = false)
       in_current_dir do
         raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
@@ -279,10 +384,10 @@ module Aruba
         RbConfig::CONFIG['ruby_install_name'])
     end
 
-    # detect_ruby(cmd) is an internal helper method that checks to see
-    # if the Aruba test cli command is ruby itself and returns the
-    # value of current_ruby to the <tt>run</tt> method and the value
-    # of cmd otherwise.
+    # detect_ruby is an internal helper method that checks to see
+    # if the Aruba test cli command is ruby itself. If so then it returns
+    # the value of current_ruby to the <tt>run</tt> method. If not then
+    # it returns the the value of cmd.
     #
     def detect_ruby(cmd)
       if cmd =~ /^ruby\s/
@@ -293,13 +398,13 @@ module Aruba
     end
 
     # This provides a regexp of commonly encountered Ruby scripts
-    # for use in testing Aruba itself.
+    # for use in testing Aruba itself. Used by detect_ruby_script.
     #
     COMMON_RUBY_SCRIPTS = \
       /^(?:bundle|cucumber|gem|jeweler|rails|rake|rspec|spec)\s/ 
 
     # detect_ruby_script is an internal helper script used in testing
-    # Aruba itself.
+    # Aruba itself. Uses COMMON_RUBY_SCRIPTS.
     #
     def detect_ruby_script(cmd)
       if cmd =~ COMMON_RUBY_SCRIPTS
@@ -325,14 +430,14 @@ module Aruba
       @dirs << aruba_working_dir
     end
 
-    # ensure_newline(str) is an internal helper method used to test interactive
+    # ensure_newline is an internal helper method used to test interactive
     # CLI programs with Aruba.
     #
     def ensure_newline(str)
       str.chomp << "\n"
     end
 
-    # in_current_dir(&block) is an internal helper method wherein all the magic
+    # in_current_dir is an internal helper method wherein all the magic
     # of Aruba takes place.  It uses the value of current_dir to determine
     # what directory to change to before running Aruba steps.
     #
@@ -341,9 +446,10 @@ module Aruba
       Dir.chdir(current_dir, &block)
     end
 
-    # install_gems(gemfile) internal helper method that uses Bundler to
-    # install the gems specified int he given Gemfile name into the
-    # current Ruby VM.
+    # install_gems internal helper method that uses up Bundler to
+    # install the gems specified in the given Gemfile name into the
+    # current Ruby VM.  If Bundler is not present then this method will
+    # attempt to install it.
     #
     def install_gems(gemfile)
       create_file("Gemfile", gemfile)
@@ -353,8 +459,8 @@ module Aruba
       end
     end
 
-    # interactive_output an internal  helper method that provides the contents
-    # of $stdout from interactive Aruba processes.
+    # interactive_output is an internal helper method that provides
+    # the contents of $stdout from interactive Aruba processes.
     # 
     def interactive_output
       @_interactive ||= if @interactive
@@ -365,11 +471,14 @@ module Aruba
       end
     end
 
-    # original_env is an internal helper method that returns a hash of the
-    # original env variables and their values for restore_original_env
-    #
-    def original_env
-      @original_env ||= {}
+    # Attribute.
+    def last_stderr
+      @last_stderr
+    end
+
+    # Attribute
+    def last_stdout
+      @last_stdout
     end
 
     # _mkdir(dir_name) is an internal helper name that does exactly as its
@@ -379,13 +488,23 @@ module Aruba
       FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
     end
 
-    # rebase(dirs=nil) creates a symbolic link in the awd to each directory
-    # contained in the passed array that are named relative to the user's
+    # original_env is an internal helper method that returns a hash of the
+    # original env variables and their values for use in restore_original_env
+    #
+    def original_env
+      @original_env ||= {}
+    end
+
+    # rebase creates a symbolic link in the awd to each directory
+    # contained in the passed array.Each entry is named relative to the user's
     # cwd.  It first checkes that the awd path contains a directory named
     # <tt>/tmp/</tt> and fails if it does not.
     #
     # Usage:
-    #   When I rebase the directory "bar/foo"$
+    #   When I rebase the directory named "bar/foo"$
+    #
+    #   When /I rebase the directory named "([^\"]*)"$/ do |dir|
+    #     rebase(dir)
     #
     def rebase(dirs=nil)
 
@@ -410,7 +529,7 @@ module Aruba
       @aruba_rebase_dirs
     end
 
-    # rebase_dirs_add(dirs=nil) is an internal helper method that
+    # rebase_dirs_add is an internal helper method that
     # adds directory names to the rebase_dirs array.
     #
     def rebase_dirs_add(dirs=nil)
@@ -440,7 +559,10 @@ module Aruba
     #   Then stdout should contain "this"
     #   Then stderr should not contain "this"
     #   Then stdout should not contain "this"
-    #   
+    #      
+    #   When /stderr should contain "([^\"]*)"$/ do |partial_output|
+    #     last_stderr.should =~ regexp(partial_output)
+
     def regexp(string_or_regexp)
       Regexp === string_or_regexp ? string_or_regexp : Regexp.compile(Regexp.escape(string_or_regexp))
     end
@@ -453,9 +575,16 @@ module Aruba
         ENV[key] = value
       end
     end
+
+    class ProcessTimeout < Timeout::Error; end
+    # Set the default timeout in seconds for external process to finish
+    # May be overrriden by setting environment variable ARUBA_RUN_TIMEOUT
+    ARUBA_RUN_TIMEOUT_DEFAULT = 2
     
-    # run(cmd, fail_on_error=true) is the internal helper method that actually
-    # runs the test executable, optionally failing if the exit status != 0.
+    # run is the internal helper method that actually runs the external 
+    # test process, optionally failing if the exit status != 0.  Takes an
+    # optional thrid parameter to specific maximum time process should
+    # take befor exiting.
     #
     # Usage:
     #   When I run "ruby -e 'puts "hello world"'
@@ -463,26 +592,57 @@ module Aruba
     #   When I run "ruby -e 'fail' with errors
     #   When I run "ruby -e 'exit' without errors
     #
-    def run(cmd, fail_on_error=true)
+    #   When /I run a long process without error/ do
+    #       run(long_process, true, 15) # allow 15 seconds.
+    #
+    #   When /run "(.*)" with timeout of "()" seconds$/ do |cmd, time|
+    #     run(unescape(cmd), true, time.to_f)
+    #   end
+    def run(cmd, fail_on_error=true, tlimit=nil)
+
+      @last_stderr = ""
+      @last_stdout = ""
       cmd = detect_ruby(cmd)
 
+      if tlimit == nil
+        if defined?(ENV[ARUBA_RUN_TIMEOUT])
+          tlimit = ENV[ARUBA_RUN_TIMEOUT]
+        else
+          tlimit = ARUBA_RUN_TIMEOUT_DEFAULT
+        end
+      else
+        tlimit = tlimit.to_f
+      end 
 
       in_current_dir do
         announce_or_puts("$ cd #{Dir.pwd}") if @announce_dir
         announce_or_puts("$ #{cmd}") if @announce_cmd
-        ps = BackgroundProcess.run(cmd)
-        @last_stdout = ps.stdout.read 
-        announce_or_puts(@last_stdout) if @announce_stdout
-        @last_stderr = ps.stderr.read
-        announce_or_puts(@last_stderr) if @announce_stderr
-        @last_exit_status = ps.exitstatus # Waits for process to finish
+        begin
+          Timeout::timeout(tlimit, ProcessTimeout) {
+            ps = BackgroundProcess.run(cmd)
+            @last_stdout = ps.stdout.read 
+            announce_or_puts(@last_stdout) if @announce_stdout
+            @last_stderr = ps.stderr.read
+            announce_or_puts(@last_stderr) if @announce_stderr 
+          # Waits for process to finish or timeout
+            @last_exit_status = ps.exitstatus
+          }
+        rescue ProcessTimeout => e
+          if @last_stderr 
+            @last_stderr += e.inspect
+          else
+            @last_stderr = e.inspect
+          end
+          @last_exit_status = -1
+          announce_or_puts(@last_exit_status.to_i.to_s) if @announce_stderr
+          announce_or_puts(@last_stderr) if @announce_stderr
+        end
       end
 
       if(@last_exit_status != 0 && fail_on_error)
         fail("Exit status was #{@last_exit_status}. Output:\n#{combined_output}")
       end
 
-      @last_stderr
     end
     
     # run_interactive(cmd) is an internal helper method that runs CLI
@@ -559,7 +719,7 @@ module Aruba
     # write_interactive(input) writes the provided string to $stdin of
     # the interactive process run by Aruba.
     # Usage
-    #   When i type "the answwer is 42"
+    #   When I type "the answwer is 42"
     #
     def write_interactive(input)
       @interactive.stdin.write(input)

data/lib/aruba/cucumber_steps.rb

@@ -56,6 +56,16 @@ When /clean up the working directory/ do
 end
 
 
+When /display stderr/ do
+  announce_or_puts(last_stderr)
+end
+
+
+When /display stdout/ do
+  announce_or_puts(last_stdout)
+end
+
+
 When /do(?:es)? have (?:a|the) directory named "([^\"]*)"$/ do |dir_name|
   create_dir(dir_name)
 end
@@ -72,12 +82,13 @@ When /do(?:es)? have an empty file named "([^\"]*)"$/ do |file_name|
 end
 
 
-When /exit status should be (\d+)$/ do |exit_status|
+When /exit status should be (-?\d+)$/ do |exit_status|
   @last_exit_status.should == exit_status.to_i
 end
 
 
-When /exit status should not be (\d+)$/ do |exit_status|
+When /exit status should not be (-?\d+)$/ do |exit_status|
+  @last_exit_status.should_not == nil
   @last_exit_status.should_not == exit_status.to_i
 end
 
@@ -193,7 +204,7 @@ When /run "(.*)"$/ do |cmd|
 end
 
 
-When /run "([^\"]*)" interactively$/ do |cmd|
+When /run "(.*)" interactively$/ do |cmd|
   run_interactive(unescape(cmd))
 end
 
@@ -203,6 +214,11 @@ When /run "(.*)" with errors?$/ do |cmd|
 end
 
 
+When /run "(.*)" with timeout of "(\d+\.?\d*)" seconds$/ do |cmd, time|
+  run(unescape(cmd), true, time.to_f)
+end
+
+
 When /run "(.*)" without errors?$/ do |cmd|
   run(unescape(cmd), true)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: aruba-jbb
 version: !ruby/object:Gem::Version 
-  hash: 87
+  hash: 85
   prerelease: false
   segments: 
   - 0
   - 2
   - 6
-  - 8
-  version: 0.2.6.8
+  - 9
+  version: 0.2.6.9
 platform: ruby
 authors: 
 - "Aslak Helles\xC3\xB8y"
@@ -97,6 +97,7 @@ files:
 - features/flushing.feature
 - features/interactive.feature
 - features/output.feature
+- features/process_timeout.feature
 - features/step_definitions/aruba_dev_steps.rb
 - features/support/env.rb
 - lib/aruba.rb
@@ -145,5 +146,6 @@ test_files:
 - features/flushing.feature
 - features/interactive.feature
 - features/output.feature
+- features/process_timeout.feature
 - features/step_definitions/aruba_dev_steps.rb
 - features/support/env.rb