aruba 0.14.14 → 1.0.0.pre.alpha.1

data/features/03_testing_frameworks/cucumber/steps/command/run_command_interactively.feature

@@ -1,90 +0,0 @@
-Feature: Running an interactive command
-
-  In order to test interactive command line applications
-  As a developer using Cucumber
-  I want to use the interactive session steps
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  @wip-jruby-java-1.6
-  Scenario: Running ruby interactively
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env ruby
-
-    while res = gets.chomp
-      break if res == "quit"
-      puts res.reverse
-    end
-    """
-    And a file named "features/interactive.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `aruba-test-cli` interactively
-        And I type "hello, world"
-        And I type "quit"
-        Then it should pass with "dlrow ,olleh"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @posix
-  Scenario: Running a native binary interactively
-    Given a file named "features/interactive.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-      When I run `cat` interactively
-      And I type "Hello, world"
-      And I type ""
-      Then the output should contain "Hello, world"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @posix
-  Scenario: Pipe in a file
-    Given a file named "features/interactive.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        Given a file named "test.txt" with "line1\nline2"
-        When I run `cat` interactively
-        And I pipe in the file "test.txt"
-        Then the output should contain "line1\nline2"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @posix
-  Scenario: Close stdin stream
-    Given a file named "features/interactive.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        When I run `cat` interactively
-        And I type "Hello, world"
-        And I close the stdin stream
-        Then the output should contain "Hello, world"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @posix
-  Scenario: All processes are stopped before checking for filesystem changes
-
-    See: http://github.com/aslakhellesoy/aruba/issues#issue/17 for context
-
-    Given a file named "features/interactive.feature" with:
-    """cucumber
-    Feature: Run command
-      Scenario: Run command
-        Given a directory named "rename_me"
-        When I run `mv rename_me renamed` interactively
-        Then the directory "renamed" should exist
-        And the directory "rename_me" should not exist
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/03_testing_frameworks/cucumber/steps/command/run_commands_which_require_a_shell.feature

@@ -1,79 +0,0 @@
-Feature: Running shell commands
-
-  You can run an *ad hoc* script with the following steps:
-  - `When I run the following script:`
-
-  Or you can run shell commands with:
-  - `I run the following commands`
-  - `I run the following commands (in|with) \`interpreter\``
-  - `I run the following commands (in|with) \`/path/to/interpreter\``
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Creating and running scripts
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running ruby script
-        When I run the following script:
-        \"\"\"bash
-        #!/usr/bin/env ruby
-
-        puts "Hello"
-        \"\"\"
-        Then the output should contain "Hello"
-
-      Scenario: Running python script
-        When I run the following script:
-        \"\"\"bash
-        #!/usr/bin/env python
-
-        print("Hello")
-        \"\"\"
-        Then the output should contain exactly "Hello"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running shell commands
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running shell commands
-        When I run the following commands:
-        \"\"\"bash
-        echo "Hello shell"
-        \"\"\"
-        Then the output should contain exactly "Hello shell"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running commands with a named interpreter
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running scripts
-      Scenario: Running ruby commands
-        When I run the following commands with `ruby`:
-        \"\"\"
-        puts "Hello, Aruba!"
-        \"\"\"
-        Then the output should contain "Hello, Aruba!"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Running commands if full path to interpreter is given
-    Given a file named "features/shell.feature" with:
-    """
-    Feature: Running full path
-      Scenario: Running full path bash
-        When I run the following commands with `/bin/bash`:
-        \"\"\"bash
-        echo "Hello Aruba!"
-        \"\"\"
-        Then the output should contain "Hello Aruba!"
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/03_testing_frameworks/cucumber/steps/command/send_signal_to_command.feature

@@ -1,83 +0,0 @@
-Feature: Send a signal to command
-
-  You can send a command a signal with the following steps:
-
-  - `When I send the signal "HUP" to the command started last`
-  - `When I send the signal "HUP" to the command "bin/aruba-test-cli"`
-
-  Or just use `kill` on compatible platforms.
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-    function hup {
-      echo "Got signal HUP."
-      exit 0
-    }
-
-    trap hup HUP
-    while [ true ]; do sleep 0.1; done
-    """
-    And a file named "features/support/aruba_config.rb" with:
-    """ruby
-    Aruba.configure do |config|
-      config.startup_wait_time = 0.1
-      config.exit_timeout = 0.2
-    end
-    """
-
-  Scenario: Sending signal to the command started last
-    Given a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        When I run `aruba-test-cli` in background
-        And I send the signal "HUP" to the command started last
-        Then the exit status should be 0
-        And the output should contain:
-        \"\"\"
-        Got signal HUP.
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Sending signal to a command given by command line
-    Given a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        When I run `aruba-test-cli` in background
-        And I send the signal "HUP" to the command "aruba-test-cli"
-        Then the exit status should be 0
-        And the output should contain:
-        \"\"\"
-        Got signal HUP.
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @unsupported-on-platform-windows
-  @experimental
-  Scenario: Using the "kill"-command
-
-    `<pid-last-command-started>` in your command line will be replaced by the
-    PID of the last command started. Please note, this feature is experimental.
-    The name of the variable may change without further notice.
-
-    Given a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        When I run `aruba-test-cli` in background
-        And I run `kill -HUP <pid-last-command-started>`
-        Then the output should contain:
-        \"\"\"
-        Got signal HUP.
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass

data/features/03_testing_frameworks/cucumber/steps/command/stop_command.feature

@@ -1,285 +0,0 @@
-Feature: Stop commands
-
-  After you've started a command, you might want to stop a command. To do that
-  you've got multiple possibilities.
-
-  On "JRuby" it's not possible to read the output of command which `echo`s a
-  string in a `signal`-handler - `TERM`, `HUP` etc. So please don't write
-  tests, which check on this, if your script needs to run on "JRuby". All other
-  output is logged to `STDERR` and/or `STDOUT` as normal.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Terminate last command started
-
-    Terminating a command will send `SIGTERM` to the command.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 100
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 155
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And a file named "features/stop.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        Given the default aruba exit timeout is 0.2 seconds
-        And I wait 0.1 seconds for a command to start up
-        When I run `aruba-test-cli1` in background
-        And I run `aruba-test-cli2` in background
-        And I terminate the command started last
-        Then the exit status should be 155
-        And the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Stop last command started
-
-    Stopping a command will wait n seconds for the command to stop and then
-    send `SIGTERM` to the command. Normally "n" is defined by the default exit
-    timeout of aruba.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 100
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 155
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And a file named "features/stop.feature" with:
-    """
-    Feature: Run it
-      Background:
-
-      Scenario: Run command
-        Given the default aruba exit timeout is 0.2 seconds
-        And I wait 0.1 seconds for a command to start up
-        When I run `aruba-test-cli1` in background
-        And I run `aruba-test-cli2` in background
-        And I stop the command started last
-        Then the exit status should be 155
-        And the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Terminate command given by commandline
-
-    Pass the commandline to the step to find the command, which should be
-    stopped.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 100
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 155
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 2
-    """
-    And a file named "features/stop.feature" with:
-    """
-    Feature: Run it
-      Background:
-        Given the default aruba exit timeout is 0.2 seconds
-
-      Scenario: Run command
-        Given I wait 0.1 seconds for a command to start up
-        When I run `aruba-test-cli1` in background
-        When I run `aruba-test-cli2` in background
-        And I terminate the command "aruba-test-cli1"
-        Then the exit status should be 100
-        And the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Stop command given by commandline
-
-    Stopping a command will wait n seconds for the command to stop and then
-    send `SIGTERM` to the command. Normally "n" is defined by the default exit
-    timeout of aruba.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 155
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      exit 100
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And a file named "features/stop.feature" with:
-    """
-    Feature: Run it
-      Background:
-        Given the default aruba exit timeout is 0.2 seconds
-
-      Scenario: Run command
-        Given I wait 0.1 seconds for a command to start up
-        When I run `aruba-test-cli1` in background
-        And I run `aruba-test-cli2` in background
-        When I stop the command "aruba-test-cli1"
-        Then the exit status should be 155
-        And the output should contain:
-        \"\"\"
-        Hello, Aruba!
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  Scenario: Stop command with configured signal
-
-    You can define a default signal which is used to stop all commands.
-
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    function hup {
-      exit 155
-    }
-
-    function term {
-      exit 100
-    }
-
-    trap hup HUP
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And a file named "features/run.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        Given the default aruba stop signal is "HUP"
-        And the default aruba exit timeout is 0.2 seconds
-        When I run `aruba-test-cli`
-        Then the exit status should be 155
-    """
-    When I run `cucumber`
-    Then the features should all pass
-
-  @requires-ruby-platform-mri
-  Scenario: STDERR/STDOUT is captured from signal handlers
-
-     STDERR/STDOUT is written normally on MRI if output was written in "signal"-handler
-
-     This is currently broken on JRuby.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/bin/bash
-
-    function term {
-      echo 'Hello, TERM'
-      exit 100
-    }
-
-    trap term TERM
-    echo "Hello, Aruba!"
-    while [ true ]; do sleep 0.1; done
-    exit 1
-    """
-    And a file named "features/stop.feature" with:
-    """
-    Feature: Run it
-      Scenario: Run command
-        Given the default aruba exit timeout is 0.2 seconds
-        And I wait 0.1 seconds for a command to start up
-        When I run `aruba-test-cli1` in background
-        And I terminate the command started last
-        Then the exit status should be 100
-        And the output should contain:
-        \"\"\"
-        Hello, TERM
-        \"\"\"
-    """
-    When I run `cucumber`
-    Then the features should all pass