aruba-win-fix 0.14.2

data/features/step_definitions/aruba_dev_steps.rb

@@ -0,0 +1,56 @@
+When /^I do aruba (.*)$/ do |aruba_step|
+  @aruba_exception = StandardError.new
+
+  begin
+    step(aruba_step)
+  rescue => e
+    @aruba_exception = e
+  end
+end
+
+# Useful for debugging timing problems
+When /^sleep (\d+)$/ do |time|
+  sleep time.to_i
+end
+
+When /^I set env variable "(\w+)" to "([^"]*)"$/ do |var, value|
+  ENV[var] = value
+end
+
+Then /^aruba should fail with "([^"]*)"$/ do |error_message|
+  expect(@aruba_exception.message).to include sanitize_text(error_message)
+end
+
+Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
+  expect{steps multiline_step.to_s}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+end
+
+Given(/^the default executable$/) do
+  step 'an executable named "bin/cli" with:', <<-EOS
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'cli/app'
+
+exit 0
+  EOS
+end
+
+Given(/^the default feature-test$/) do
+  step(
+    'a file named "features/default.feature" with:',
+    <<-EOS.strip_heredoc
+    Feature: Default Feature
+
+      This is the default feature
+
+      Scenario: Run command
+        Given I successfully run `cli`
+    EOS
+  )
+end
+
+Then(/^aruba should be installed on the local system$/) do
+  run('gem list aruba')
+  expect(last_command_started).to have_output(/aruba/)
+end

data/features/step_definitions/hooks.rb

@@ -0,0 +1,96 @@
+require 'cucumber/platform'
+
+Before '@requires-ruby-version-193' do |scenario|
+  next if RUBY_VERSION >= '1.9.3'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@requires-ruby-version-19' do |scenario|
+  next if RUBY_VERSION >= '1.9'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@requires-ruby-version-2' do |scenario|
+  next if RUBY_VERSION >= '2'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@requires-aruba-version-1' do |scenario|
+  next if Aruba::VERSION > '1'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@requires-ruby-platform-java' do |scenario|
+  # leave if java
+  next if RUBY_PLATFORM.include? 'java'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@requires-ruby-platform-mri' do |scenario|
+  # leave if not java
+  next unless RUBY_PLATFORM.include? 'java'
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@unsupported-on-platform-windows' do |scenario|
+  # leave if not windows
+  next unless FFI::Platform.windows?
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@unsupported-on-platform-unix' do |scenario|
+  # leave if not windows
+  next unless FFI::Platform.unix?
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end
+
+Before '@unsupported-on-platform-mac' do |scenario|
+  # leave if not windows
+  next unless FFI::Platform.mac?
+
+  if Cucumber::VERSION < '2'
+    scenario.skip_invoke!
+  else
+    skip_this_scenario
+  end
+end

data/features/steps/command/debug.feature

@@ -0,0 +1,92 @@
+Feature: Debug your command in cucumber-test-run
+
+  As a developer
+  I want to use some debugger in my code and therefor need system() to execute my program
+  In order to find a bug
+
+  Background:
+    Given I use a fixture named "cli-app"
+    And the default aruba exit timeout is 60 seconds
+
+  Scenario: Can handle exit status 0
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    exit 0
+    """
+    And a file named "features/debug.feature" with:
+    """cucumber
+    Feature: Exit status in debug environment
+
+      @debug
+      Scenario: Run program with debug code
+        When I run `cli`
+        Then the exit status should be 0
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Can handle exit status 1
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    exit 1
+    """
+    And a file named "features/debug.feature" with:
+    """cucumber
+    Feature: Exit status in debug environment
+
+      @debug
+      Scenario: Run program with debug code
+        When I run `cli`
+        Then the exit status should be 1
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: You can use a debug repl in your cli program
+
+    If you want to debug a strange error, which only occures in one of your
+    `cucumber`-tests, the `@debug`-tag becomes handy. You can add `@debug` in
+    front of your feature/scenario to make `binding.pry` or `byebug` work in
+    your program.
+
+    Please make sure, that there's a statement after the `binding.pry`-call.
+    Otherwise you might not get an interactive shell, because your program will
+    just exit.
+
+    We are going to demonstrate this using `pry`, but any other interactive
+    debugger for any other programming language should also work.
+
+    Given an executable named "bin/cli" with:
+    """ruby
+    #!/usr/bin/env ruby
+
+    $stderr.sync = true
+    $stdout.sync = true
+
+    require 'pry'
+    binding.pry
+
+    exit 0
+    """
+    And a file named "features/debug.feature" with:
+    """cucumber
+    Feature: Exit status in debug environment
+
+      @debug
+      Scenario: Run program with debug code
+        When I run `cli`
+        Then the exit status should be 0
+    """
+    When I run `cucumber` interactively
+    And I stop the command started last if output contains:
+    """
+    pry(main)>
+    """
+    Then the output should match:
+    """
+    7:\s+binding.pry
+    """

data/features/steps/command/exit_statuses.feature

@@ -0,0 +1,136 @@
+Feature: Check exit status of commands
+
+  Use the `the exit status should be \d`-step to check the exit status of the
+  last command which was executed.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Test for exit status of 0
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Exit status
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Test for exit status 1
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should be 1
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Test for non-zero exit status
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I run `cli`
+        Then the exit status should not be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Successfully run something
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Fail to run something successfully
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should not all pass
+
+  Scenario: Overwrite the default exit timeout via step
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba exit timeout is 2 seconds
+        When I successfully run `cli`
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Successfully run something longer then the default time
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba exit timeout is 0 seconds
+        When I successfully run `cli` for up to 2 seconds
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Unsuccessfully run something that takes too long
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    sleep 2
+    """
+    And a file named "features/exit_status.feature" with:
+    """
+    Feature: Failing program
+      Scenario: Run command
+        Given the default aruba exit timeout is 0 seconds
+        When I successfully run `cli` for up to 1 seconds
+    """
+    When I run `cucumber`
+    Then the features should not all pass with:
+    """
+    expected "cli" to have finished in time
+    """

data/features/steps/command/in_process.feature

@@ -0,0 +1,485 @@
+Feature: Run commands in ruby process
+  Running a lot of scenarios where each scenario uses Aruba
+  to spawn a new ruby process can be time consuming.
+
+  Aruba lets you plug in your own process class that can
+  run a command in the same ruby process as Cucumber/Aruba.
+
+  We expect that the command supports the following API. It needs to accept:
+  argv, stdin, stdout, stderr and kernel on `#initialize` and it needs to have
+  an `execute!`-method.
+
+  ```ruby
+  module Cli
+    module App
+      class Runner
+        def initialize(argv, stdin, stdout, stderr, kernel)
+          \@argv   = argv
+          \@stdin  = stdin
+          \@stdout = stdout
+          \@stderr = stderr
+          \@kernel = kernel
+        end
+
+        def execute!
+        end
+      end
+    end
+  end
+  ```
+
+  The switch to the working directory takes place around the `execute!`-method.
+  If needed make sure, that you determine the current working directory within
+  code called by the `execute!`-method or just use `Dir.getwd` during "runtime"
+  and not during "loadtime", when the `ruby`-interpreter reads in you class
+  files.
+
+  *Pros*:
+  * Very fast compared to spawning processes
+  * You can use libraries like
+    [simplecov](https://github.com/colszowka/simplecov) more easily, because
+    there is only one "process" which adds data to `simplecov`'s database
+
+  *Cons*:
+  * You might oversee some bugs: You might forget to require libraries in your
+    "production" code, because you have required them in your testing code
+  * Using `:in_process` interactively is not supported
+
+  **WARNING**: Using `:in_process` interactively is not supported
+
+  Background:
+    Given I use a fixture named "cli-app"
+    And a file named "features/support/cli_app.rb" with:
+    """
+    require 'cli/app/runner'
+    """
+    And a file named "features/support/in_proccess.rb" with:
+    """
+    require 'aruba/cucumber'
+
+    Before('@in-process') do
+      aruba.config.command_launcher = :in_process
+      aruba.config.main_class = Cli::App::Runner
+    end
+
+    After('@in-process') do
+      aruba.config.command_launcher = :spawn
+    end
+    """
+
+  Scenario: Run custom code
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts(@argv.map(&:reverse).join(' '))
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `reverse.rb Hello World`
+        Then the output should contain:
+        \"\"\"
+        olleH dlroW
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Mixing custom code and normal cli
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    echo $*
+    """
+    And a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts(@argv.map(&:reverse).join(' '))
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command in process
+        When I run `reverse.rb Hello World`
+        Then the output should contain:
+        \"\"\"
+        olleH dlroW
+        \"\"\"
+
+      Scenario: Run command
+        When I run `cli Hello World`
+        Then the output should contain:
+        \"\"\"
+        Hello World
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: The current working directory is changed as well
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts("PWD-ENV is " + Dir.getwd)
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `pwd.rb`
+        Then the output should match %r<PWD-ENV.*tmp/aruba>
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: The PWD environment is changed to current working directory
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts("PWD-ENV is " + ENV['PWD'])
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `pwd.rb`
+        Then the output should match %r<PWD-ENV.*tmp/aruba>
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Set runner via "Aruba.process ="-method (deprecated)
+    Given a file named "features/support/in_proccess.rb" with:
+    """
+    require 'aruba/cucumber'
+    require 'aruba/processes/in_process'
+
+    Before('@in-process') do
+      Aruba.process = Aruba::Processes::InProcess
+      Aruba.process.main_class = Cli::App::Runner
+    end
+
+    After('@in-process') do
+      Aruba.process = Aruba::Processes::SpawnProcess
+    end
+    """
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts(@argv.map(&:reverse).join(' '))
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `reverse.rb Hello World`
+        Then the output should contain:
+        \"\"\"
+        olleH dlroW
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Set runner via "Aruba.process ="-method and use old class name Aruba::InProcess (deprecated)
+    Given a file named "features/support/in_proccess.rb" with:
+    """
+    require 'aruba/cucumber'
+    require 'aruba/in_process'
+    require 'aruba/spawn_process'
+
+    Before('@in-process') do
+      Aruba.process = Aruba::InProcess
+      Aruba.process.main_class = Cli::App::Runner
+    end
+
+    After('@in-process') do
+      Aruba.process = Aruba::SpawnProcess
+    end
+    """
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            @stdin  = stdin
+            @stdout = stdout
+            @stderr = stderr
+            @kernel = kernel
+          end
+
+          def execute!
+            @stdout.puts(@argv.map(&:reverse).join(' '))
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `reverse.rb Hello World`
+        Then the output should contain:
+        \"\"\"
+        olleH dlroW
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Use $stderr, $stdout and $stdin to access IO
+
+    May may need/want to use the default `STDERR`, `STDOUT`, `STDIN`-constants
+    to access IO from within your script. Unfortunately this does not work with
+    the `:in_process`-command launcher. You need to use `$stderr`, `$stdout`
+    and `$stdin` instead.
+
+    For this example I chose `thor` to parse ARGV. Its `.start`-method accepts
+    an "Array" as ARGV and a "Hash" for some other options &ndash; `.start <ARGV>, <OPTIONS>`
+
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    require 'cli/app/cli_parser'
+
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            $kernel = kernel
+            $stdin  = stdin
+            $stdout = stdout
+            $stderr = stderr
+          end
+
+          def execute!
+            Cli::App::CliParser.start @argv
+          end
+        end
+      end
+    end
+    """
+    And a file named "lib/cli/app/cli_parser.rb" with:
+    """
+    require 'thor'
+
+    module Cli
+      module App
+        class CliParser < Thor
+          def self.exit_on_failure?
+            true
+          end
+
+          desc 'do_it', 'Reverse input'
+          def do_it(*args)
+            $stderr.puts 'Hey ya, Hey ya, check, check, check'
+            $stdout.puts(args.flatten.map(&:reverse).join(' '))
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `reverse.rb do_it Hello World`
+        Then the stdout should contain:
+        \"\"\"
+        olleH dlroW
+        \"\"\"
+        And the stderr should contain:
+        \"\"\"
+        Hey ya, Hey ya, check, check, check
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Use $kernel to use Kernel to capture exit code
+
+    Ruby's `Kernel`-module provides some helper methods like `exit`.
+    Unfortunately running `#exit` with `:in_process` would make the whole ruby
+    interpreter exit. So you might want to use our `FakeKernel`-module module
+    instead which overwrites `#exit`. This will also make our tests for
+    checking the exit code work. This example also uses the `thor`-library.
+
+    Given a file named "lib/cli/app/runner.rb" with:
+    """
+    require 'cli/app/cli_parser'
+
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @argv   = argv
+            $kernel = kernel
+            $stdin  = stdin
+            $stdout = stdout
+            $stderr = stderr
+          end
+
+          def execute!
+            Cli::App::CliParser.start @argv
+          end
+        end
+      end
+    end
+    """
+    And a file named "lib/cli/app/cli_parser.rb" with:
+    """
+    require 'thor'
+
+    module Cli
+      module App
+        class CliParser < Thor
+          def self.exit_on_failure?
+            true
+          end
+
+          desc 'do_it', 'Reverse input'
+          def do_it(*args)
+            $kernel.exit 5
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        When I run `reverse.rb do_it`
+        Then the exit status should be 5
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Using `:in_process` interactively is not supported
+
+    Reading from STDIN blocks ruby from going on. But writing to STDIN - e.g.
+    type some letters on keyboard - can only appear later, but this point is
+    never reached, because ruby is blocked.
+
+    Given the default aruba exit timeout is 5 seconds
+    And a file named "lib/cli/app/runner.rb" with:
+    """
+    module Cli
+      module App
+        class Runner
+          def initialize(argv, stdin, stdout, stderr, kernel)
+            @stdin  = stdin
+          end
+
+          def execute!
+            while res = @stdin.gets.to_s.chomp
+              break if res == 'quit'
+              puts res.reverse
+            end
+          end
+        end
+      end
+    end
+    """
+    And a file named "features/in_process.feature" with:
+    """
+    Feature: Run a command in process
+      @in-process
+      Scenario: Run command
+        Given the default aruba exit timeout is 2 seconds
+        When I run `reverse.rb do_it` interactively
+        When I type "hello"
+        Then the output should contain:
+        \"\"\"
+        hello
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the exit status should not be 0