aruba 0.10.2 → 0.11.0.pre

data/features/steps/{commands → command}/in_process.feature

@@ -34,6 +34,8 @@ Feature: Run commands in ruby process
   and not during "loadtime", when the `ruby`-interpreter reads in you class
   files.
 
+  **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:
@@ -298,3 +300,175 @@ Feature: Run commands in ruby process
     """
     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

data/features/steps/{commands → command}/run.feature

@@ -19,3 +19,4 @@ Feature: Run commands
     """
     When I run `cucumber`
     Then the features should all pass
+

data/features/steps/command/send_signal.feature

@@ -0,0 +1,104 @@
+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/cli"`
+
+  Or just use `kill` on compatible platforms.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Sending signal to the command started last
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+    function hup {
+      echo "Got signal HUP."
+      exit 0
+    }
+
+    trap hup HUP
+    while [ true ]; do sleep 1; done
+    """
+    And a file named "features/run.feature" with:
+    """
+    Feature: Run it
+      Scenario: Run command
+        Given the default aruba exit timeout is 5 seconds
+        And I wait 5 seconds for a command to start up
+        When I run `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 an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+    function hup {
+      echo "Got signal HUP."
+      exit 0
+    }
+
+    trap hup HUP
+    while [ true ]; do sleep 1; done
+    """
+    And a file named "features/run.feature" with:
+    """
+    Feature: Run it
+      Scenario: Run command
+        Given the default aruba exit timeout is 5 seconds
+        And I wait 5 seconds for a command to start up
+        When I run `cli` in background
+        And I send the signal "HUP" to the command "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 an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+    function hup {
+      echo "Got signal HUP."
+      exit 0
+    }
+
+    trap hup HUP
+    while [ true ]; do sleep 1; done
+    """
+    And a file named "features/run.feature" with:
+    """
+    Feature: Run it
+      Scenario: Run command
+        Given the default aruba exit timeout is 5 seconds
+        And I wait 5 seconds for a command to start up
+        When I run `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/steps/command/stop.feature

@@ -0,0 +1,313 @@
+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/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    exit 1
+    """
+    And an executable named "bin/cli2" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 155
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 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 1 second
+        And I wait 2 seconds for a command to start up
+        When I run `cli1` in background
+        And I run `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/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    exit 1
+    """
+    And an executable named "bin/cli2" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 155
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 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 5 seconds
+        And I wait 2 seconds for a command to start up
+        When I run `cli1` in background
+        And I run `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/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    """
+    And an executable named "bin/cli2" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 155
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    exit 2
+    """
+    And a file named "features/stop.feature" with:
+    """
+    Feature: Run it
+      Background:
+        Given the default aruba exit timeout is 5 seconds
+
+      Scenario: Run command
+        Given I wait 2 seconds for a command to start up
+        When I run `cli1` in background
+        When I run `cli2` in background
+        And I terminate the command "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/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 155
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    exit 1
+    """
+    And an executable named "bin/cli2" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 1; done
+    exit 1
+    """
+    And a file named "features/stop.feature" with:
+    """
+    Feature: Run it
+      Background:
+        Given the default aruba exit timeout is 5 seconds
+
+      Scenario: Run command
+        Given I wait 2 seconds for a command to start up
+        When I run `cli1` in background
+        And I run `cli2` in background
+        When I stop the command "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/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 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 5 seconds
+        When I run `cli`
+        Then the exit status should be 155
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  @requires-ruby-platform-java
+  Scenario: STDERR/STDOUT is empty on JRUBY if output was written in "signal"-handler
+    Given an executable named "bin/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      echo 'Hello, TERM'
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 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 1 second
+        And I wait 2 seconds for a command to start up
+        When I run `cli1` in background
+        And I terminate the command started last
+        Then the exit status should be 100
+        And the output should not contain:
+        \"\"\"
+        Hello, TERM
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  @requires-ruby-platform-mri
+  Scenario: STDERR/STDOUT is written normally with MRI-Ruby if output was written in "signal"-handler
+    Given an executable named "bin/cli1" with:
+    """bash
+    #!/bin/bash
+
+    function term {
+      echo 'Hello, TERM'
+      exit 100
+    }
+
+    trap term TERM
+    echo "Hello, Aruba!"
+    while [ true ]; do sleep 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 1 second
+        And I wait 2 seconds for a command to start up
+        When I run `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