aruba-win-fix 0.14.2

data/features/configuration/usage.feature

@@ -0,0 +1,159 @@
+Feature: Usage of configuration
+
+  You can configure `aruba` in two ways:
+
+  1. Using `Aruba.configure`-block
+  2. Using `aruba.config.<option> = <value>`
+
+  The first (1.) should be used to set defaults for ALL your tests. It changes
+  values on loadtime. The latter (2.) should be used to change options only for
+  specific tests during runtime. `aruba.config` contains the runtime
+  configuration of aruba which is reset to the loadtime configuration before
+  each test is run.
+
+  Background:
+    Given I use a fixture named "cli-app"
+    And an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    trap "exit 128" SIGTERM SIGINT
+    sleep $*
+    """
+
+  Scenario: Setting default values for option for RSpec
+    Given a file named "spec/support/aruba.rb" with:
+    """ruby
+    require 'aruba/rspec'
+
+    Aruba.configure do |config|
+      config.exit_timeout = 1
+    end
+    """
+    And a file named "spec/usage_configuration_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      context 'when fast command' do
+        before(:each) { run('cli 0') }
+        it { expect(last_command_started).to be_successfully_executed }
+      end
+
+      context 'when slow command' do
+        before(:each) { run('cli 2') }
+        it { expect(last_command_started).not_to be_successfully_executed }
+      end
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Setting option during runtime for RSpec
+
+    Maybe there are some long running tests, which need longer. You may not
+    want to set the default timeout for all commands to the maximum value only
+    to prevent those commands from failing.
+
+    Given a file named "spec/support/aruba.rb" with:
+    """ruby
+    require 'aruba/rspec'
+
+    Aruba.configure do |config|
+      config.exit_timeout = 1
+    end
+    """
+    And a file named "spec/support/hooks.rb" with:
+    """ruby
+    RSpec.configure do |config|
+      config.before :each do |example|
+        next unless example.metadata.key? :slow_command
+
+        aruba.config.exit_timeout = 5
+      end
+    end
+    """
+    And a file named "spec/usage_configuration_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      context 'when fast command' do
+        before(:each) { run('cli 0') }
+        it { expect(last_command_started).to be_successfully_executed }
+      end
+
+      context 'when slow command and this is known by the developer', :slow_command => true do
+        before(:each) { run('cli 2') }
+        it { expect(last_command_started).to be_successfully_executed }
+      end
+
+      context 'when slow command, but this might be a failure' do
+        before(:each) { run('cli 2') }
+        it { expect(last_command_started).not_to be_successfully_executed }
+      end
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Setting default values for option for Cucumber
+    Given a file named "features/support/aruba.rb" with:
+    """ruby
+    require 'aruba/cucumber'
+
+    Aruba.configure do |config|
+      config.exit_timeout = 1
+    end
+    """
+    And a file named "features/run.feature" with:
+    """
+    Feature: Run it
+      Scenario: Fast command
+        When I run `cli 0`
+        Then the exit status should be 0
+
+      Scenario: Slow command
+        When I run `cli 2`
+        Then the exit status should be 128
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Setting option during runtime for Cucumber
+
+    Maybe there are some long running tests, which need longer. You may not
+    want to set the default timeout for all commands to the maximum value only
+    to prevent those commands from failing.
+
+    Given a file named "features/support/aruba.rb" with:
+    """ruby
+    require 'aruba/cucumber'
+
+    Aruba.configure do |config|
+      config.exit_timeout = 1
+    end
+    """
+    And a file named "features/support/hooks.rb" with:
+    """ruby
+    Before '@slow-command' do
+      aruba.config.exit_timeout = 5
+    end
+    """
+    And a file named "features/usage_configuration.feature" with:
+    """
+    Feature: Run it
+      Scenario: Fast command
+        When I run `cli 0`
+        Then the exit status should be 0
+
+      @slow-command
+      Scenario: Slow command known by the developer
+        When I run `cli 2`
+        Then the exit status should be 0
+
+      Scenario: Slow command which might be a failure
+        When I run `cli 3`
+        Then the exit status should be 128
+    """
+    When I run `cucumber`
+    Then the features should all pass

data/features/configuration/working_directory.feature

@@ -0,0 +1,33 @@
+Feature: Configure working directory of aruba
+
+  As a developer
+  I want to configure the working directory of aruba
+  In order to have a test directory for each used spec runner - e.g. cucumber or rspec
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Default value
+    Given a file named "features/support/aruba.rb" with:
+    """
+    Aruba.configure do |config|
+      puts %(The default value is "#{config.working_directory}")
+    end
+    """
+    When I successfully run `cucumber`
+    Then the output should contain:
+    """
+    The default value is "tmp/aruba"
+    """
+
+  Scenario: Modify value
+    Given a file named "features/support/aruba.rb" with:
+    """
+    Aruba.configure do |config|
+      config.working_directory = 'tmp/cucumber'
+    end
+    """
+    And the default feature-test
+    And the default executable
+    When I successfully run `cucumber`
+    Then a directory named "tmp/cucumber" should exist

data/features/development/build.feature

@@ -0,0 +1,15 @@
+Feature: Build Aruba Gem
+
+  As a aruba developer
+  I want to build the `aruba` gem
+  In order to install it
+
+  Scenario: Building aruba using rake task
+
+    To build the `aruba`-gem you can use the `build`-rake task.
+
+    Given I successfully run `rake -T build`
+    Then the output should contain:
+    """
+    build
+    """

data/features/development/test.feature

@@ -0,0 +1,24 @@
+Feature: Run test suite of aruba
+
+  As a aruba developer
+  I want to run the test suite of aruba
+  In order to make changes to it
+
+  Background:
+    Given the default aruba exit timeout is 120 seconds
+    And I successfully run `git clone https://github.com/cucumber/aruba.git`
+    And I cd to "aruba"
+
+  @ignore
+  Scenario: Testing user interface
+    Given I successfully run `cucumber`
+    Then the features should all pass
+
+  @unsupported-on-ruby-older-193
+  Scenario: Testing compliance to ruby community guide
+    Given I successfully run `rubocop`
+    Then the features should all pass
+
+  Scenario: Testing api
+    Given I successfully run `rspec`
+    Then the features should all pass

data/features/getting_started/cleanup.feature

@@ -0,0 +1,67 @@
+Feature: Cleanup Aruba Working Directory
+
+  By default Aruba removes its scratch directory before
+  every scenario. This isn't always the right thing
+  to do, especially when the path to the default directory
+  has been changed. Use @no-clobber to stop Aruba from
+  cleaning up after itself.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Changes in the filesystem
+    Given a file named "tmp/aruba/file.txt" with "content"
+    And a directory named "tmp/aruba/dir.d"
+    And a file named "features/flushing.feature" with:
+    """
+    Feature: Check
+      Scenario: Check
+        Then a file named "file.txt" does not exist
+        And a directory named "dir.d" does not exist
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Do not clobber before run
+    Given a file named "tmp/aruba/file.txt" with "content"
+    And a directory named "tmp/aruba/dir.d"
+    And a file named "features/flushing.feature" with:
+    """
+    Feature: Check
+      @no-clobber
+      Scenario: Check
+        Then a file named "file.txt" should exist
+        And a directory named "dir.d" should exist
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Cleanup and verify the previous scenario
+    Given a file named "features/flushing.feature" with:
+    """
+    Feature: Check
+      Scenario: Check #1
+        Given a file named "tmp/aruba/file.txt" with "content"
+        And a directory named "tmp/aruba/dir.d"
+
+      Scenario: Check #2
+        Then a file named "file.txt" should not exist
+        And a directory named "dir.d" should not exist
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario:  Current directory from previous scenario is reseted
+    Given a file named "features/non-existence.feature" with:
+    """
+    Feature: Reset
+      Scenario: Reset #1
+        Given a directory named "dir1"
+        When I cd to "dir1"
+
+      Scenario: Reset #2
+        When I run `pwd`
+        Then the output should match %r</tmp/aruba$>
+    """
+    When I run `cucumber`
+    Then the features should all pass

data/features/getting_started/install.feature

@@ -0,0 +1,8 @@
+Feature: Install aruba
+
+  Background:
+    Given the default aruba exit timeout is 60 seconds
+
+  Scenario: Using rubygems
+    Given I successfully run `gem install aruba`
+    Then aruba should be installed on the local system

data/features/getting_started/run_commands.feature

@@ -0,0 +1,177 @@
+Feature: Run commands with Aruba
+
+  As long as you've got the neccessary programs, libraries, runtime
+  environments, interpreters installed, it doesn't matter in which programming
+  language your commandline application is implemented. You can even use POSIX
+  standard tools like "printf".
+
+  Below you find some examples of the "Hello, Aruba!"-application implemented
+  with different programming languages and a single example for a POSIX
+  standard tool. This is NOT an exclusive list. Every commandline application
+  should run with `aruba`.
+
+  Background:
+    Given I use a fixture named "getting-started-app"
+    And a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given I successfully run `cli`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+
+  Scenario: Bash Program
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    echo "Hello, Aruba!"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Bash Program run via bash
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.sh" with:
+        \"\"\"
+        echo "Hello, Aruba!"
+        \"\"\"
+        When I successfully run `bash ./cli.sh`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Ruby Program
+    Given an executable named "bin/cli" with:
+    """ruby
+    #!/usr/bin/env ruby
+
+    puts "Hello, Aruba!"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Ruby Program via "ruby"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.rb" with:
+        \"\"\"
+        puts "Hello, Aruba!"
+        \"\"\"
+        When I successfully run `ruby ./cli.rb`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Python Program
+    Given an executable named "bin/cli" with:
+    """python
+    #!/usr/bin/env python
+
+    print("Hello, Aruba!")
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Python Program via "python"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.py" with:
+        \"\"\"
+        print("Hello, Aruba!")
+        \"\"\"
+        When I successfully run `python ./cli.py`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Perl Program
+    Given an executable named "bin/cli" with:
+    """perl
+    #!/usr/bin/env perl
+
+    print "Hello, Aruba!\n";
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Perl Program via "perl"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.pl" with:
+        \"\"\"perl
+        print "Hello, Aruba!\n";
+        \"\"\"
+        When I successfully run `perl ./cli.pl`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Java Program
+
+    It's even possible to compile and run Java programs with Aruba.
+
+    Given a file named "features/hello_aruba.feature" with:
+    """cucumber
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "tmp/HelloArubaApp.java" with:
+        \"\"\"
+        class HelloArubaApp {
+          public static void main(String[] args) {
+            System.out.println("Hello, Aruba!");
+          }
+        }
+        \"\"\"
+        And I successfully run `javac tmp/HelloArubaApp.java`
+        And I cd to "tmp/"
+        And I successfully run `java HelloArubaApp`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: POSIX standard tools
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given I successfully run `printf "%s" "Hello, Aruba!"`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass