aruba 0.11.0.pre4 → 0.11.1

data/features/{core/cleanup_aruba_directory.feature → getting_started/cleanup.feature}

@@ -1,4 +1,4 @@
-Feature: No clobber
+Feature: Cleanup Aruba Working Directory
 
   By default Aruba removes its scratch directory before
   every scenario. This isn't always the right thing
@@ -50,3 +50,18 @@ Feature: No clobber
     """
     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/writing_good_feature_tests.feature

@@ -0,0 +1,38 @@
+Feature: Writing good feature tests with aruba to create documentations
+
+  You can use Markdown within your feature tests. This is quite good to write a
+  living documentation.
+
+  There are some edge cases where Gherkin and Markdown don't agree. Bullet lists
+  using `*` is one example. The `*` is also an alias for step keywords in
+  Gherkin. Markdown headers (the kind starting with a `#`) is another example.
+  They are parsed as comments by Gherkin. To use either of these, just escape
+  them with a backslash. Alternatively just use the "-".
+
+  You'd write:
+
+  ```gherkin
+  Scenario: Make tea
+    \## Making tea
+    \* Get a pot
+    \* And some hot water
+
+    Given...
+  ```
+
+  This way Gherkin won't recognize these lines as special tokens, and the
+  reporter will render them as Markdown. (The reporter strips away any leading
+  the backslashes before handing it off to the Markdown parser).
+
+  Another option is to use alternative Markdown syntax and omit conflicts and
+  escaping altogether:
+
+  ```gherkin
+  Scenario: Make tea
+    Making tea
+    ----------
+    - Get a pot
+    - And some hot water
+
+    Given...
+  ```

data/features/hooks/after/command.feature

@@ -3,6 +3,16 @@ Feature: After command hooks
   You can configure Aruba to run blocks of code after it has run
   a command. The command will be passed to the block.
 
+  You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
+
+  ```ruby
+  Aruba.configure do |config|
+    config.after :command do |cmd|
+      puts "After the run of '#{cmd}'"
+    end
+  end
+  ```
+
   Background:
     Given I use a fixture named "cli-app"
 

data/features/hooks/before/command.feature

@@ -5,6 +5,16 @@ Feature: before_cmd hooks
 
   The command will be passed to the block.
 
+  You can hook into Aruba's lifecycle just before it runs a command and after it has run the command:
+
+  ```ruby
+  Aruba.configure do |config|
+    config.before :command do |cmd|
+      puts "About to run '#{cmd}'"
+    end
+  end
+  ```
+
   Background:
     Given I use a fixture named "cli-app"
 

data/features/platforms/jruby.feature

@@ -0,0 +1,14 @@
+Feature: Support for JRuby
+
+  Improve startup time by disabling JIT and forcing client JVM mode.  This can
+  be accomplished by adding
+
+  ```ruby
+  require 'aruba/jruby'
+  ```
+
+  *Note* - no conflict resolution on the JAVA/JRuby environment options is
+  done; only merging. For more complex settings please manually set the
+  environment variables in the hook or externally.
+
+  Refer to http://blog.headius.com/2010/03/jruby-startup-time-tips.html for other tips on startup time.

data/features/steps/command/in_process.feature

@@ -34,6 +34,17 @@ Feature: Run commands in ruby process
   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:

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

@@ -1,4 +1,4 @@
-Feature: Interactive process control
+Feature: Running an interactive command
 
   In order to test interactive command line applications
   As a developer using Cucumber

data/features/{commands/output/all_output.feature → steps/command/output.feature}

@@ -444,3 +444,145 @@ Feature: All output of commands which were executed
     """
     When I run `cucumber`
     Then the features should all pass
+
+  Scenario: Handle little output
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    for ((c=0; c<256; c = c+1)); do 
+      echo -n "a"
+    done
+    """
+    And a file named "features/flushing.feature" with:
+    """cucumber
+    Feature: Flushing output
+      Scenario: Run command
+        When I run `cli`
+        Then the output should contain "a"
+        And the output should be 256 bytes long
+        And the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Handle tons of output
+
+    In order to test processes that output a lot of data
+    As a developer using Aruba
+    I want to make sure that large amounts of output aren't buffered
+
+    Given the default aruba exit timeout is 10 seconds
+    And an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    for ((c=0; c<65536; c = c+1)); do
+      echo -n "a"
+    done
+    """
+    And a file named "features/flushing.feature" with:
+    """cucumber
+    Feature: Flushing output
+      Scenario: Run command
+        When I run `cli`
+        Then the output should contain "a"
+        And the output should be 65536 bytes long
+        And the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Handle tons of interactive output
+    Given the default aruba exit timeout is 10 seconds
+    And an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    read size; for ((c=0; c<$size; c = c+1)); do
+      echo -n "a"
+    done
+    """
+    And a file named "features/flushing.feature" with:
+    """cucumber
+    Feature: Flushing output
+      Scenario: Run command
+        When I run `cli` interactively
+        And I type "65536"
+        Then the output should contain "a"
+        And the output should be 65536 bytes long
+        And the exit status should be 0
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  @requires-aruba-version-1
+  Scenario: Detect output from all processes normal and interactive ones
+    Given an executable named "bin/cli1" with:
+    """
+    #!/usr/bin/env bash
+    echo 'This is cli1'
+    """
+    And an executable named "bin/cli2" with:
+    """
+    #!/usr/bin/env ruby
+
+    while input = gets do
+      break if "" == input
+      puts input
+    end
+    """
+    And a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `cli1`
+        When I run `cli2` interactively
+        And I type "This is cli2"
+        And I type ""
+        Then the stdout should contain exactly:
+        \"\"\"
+        This is cli1
+        \"\"\"
+        And the stdout should contain exactly:
+        \"\"\"
+        This is cli2
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect output from named source
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `printf 'simple'`
+        And I run `cat` interactively
+        And I type "interactive"
+        And I type ""
+        Then the output from "printf 'simple'" should contain "simple"
+        And the output from "printf 'simple'" should contain exactly "simple"
+        And the output from "printf 'simple'" should contain exactly:
+        \"\"\"
+        simple
+        \"\"\"
+        And the output from "cat" should not contain "simple"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect second output from named source with custom name
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I set the environment variable "ARUBA_TEST_VAR" to "first"
+        And I run `bash -c 'printf $ARUBA_TEST_VAR'`
+        Then the output from "bash -c 'printf $ARUBA_TEST_VAR'" should contain "first"
+        When I set the environment variable "ARUBA_TEST_VAR" to "second"
+        And I run `bash -c 'printf $ARUBA_TEST_VAR'`
+        Then the output from "bash -c 'printf $ARUBA_TEST_VAR'" should contain "second"
+    """
+    When I run `cucumber`
+    Then the features should all pass

data/features/steps/command/stderr.feature

@@ -0,0 +1,68 @@
+Feature: STDERR of commands which were executed
+
+  In order to specify expected output
+  As a developer using Cucumber
+  I want to use the "the stderr should contain" step
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Detect stderr from all processes
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `bash -c 'printf "hello world!\n" >&2'`
+        And I run `bash -c 'cat >&2 '` interactively
+        And I type "hola"
+        And I type ""
+        Then the stderr should contain:
+        \"\"\"
+        hello world!
+        \"\"\"
+        And the stderr should contain:
+        \"\"\"
+        hola
+        \"\"\"
+        And the stdout should not contain anything
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect stderr from all processes (deprecated)
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `bash -c 'printf "hello world!\n" >&2'`
+        And I run `bash -c 'cat >&2 '` interactively
+        And I type "hola"
+        And I type ""
+        Then the stderr should contain:
+        \"\"\"
+        hello world!
+        hola
+        \"\"\"
+        And the stdout should not contain anything
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect stderr from named source
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `bash -c 'printf hello >&2'`
+        And I run `printf goodbye`
+        Then the stderr from "bash -c 'printf hello >&2'" should contain "hello"
+        And the stderr from "bash -c 'printf hello >&2'" should contain exactly "hello"
+        And the stderr from "bash -c 'printf hello >&2'" should contain exactly:
+        \"\"\"
+        hello
+        \"\"\"
+        And the stdout from "bash -c 'printf hello >&2'" should not contain "hello"
+        And the stderr from "printf goodbye" should not contain "hello"
+    """
+    When I run `cucumber`
+    Then the features should all pass

data/features/{commands/output → steps/command}/stdout.feature

@@ -1,8 +1,8 @@
-Feature: Stdout of commands which were executed
+Feature: STDOUT of commands which were executed
 
   In order to specify expected output
   As a developer using Cucumber
-  I want to use the "the output should contain" step
+  I want to use the "the stdout should contain" step
 
   Background:
     Given I use a fixture named "cli-app"
@@ -64,3 +64,46 @@ Feature: Stdout of commands which were executed
     """
     When I run `cucumber`
     Then the features should all pass
+
+  Scenario: Detect stdout from all processes including interactive ones
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `printf "hello world!\n"`
+        And I run `cat` interactively
+        And I type "hola"
+        And I type ""
+        Then the stdout should contain:
+        \"\"\"
+        hello world!
+        \"\"\"
+        And the stdout should contain:
+        \"\"\"
+        hola
+        \"\"\"
+        And the stderr should not contain anything
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Detect stdout from named source
+    Given a file named "features/output.feature" with:
+    """
+    Feature: Run command
+      Scenario: Run command
+        When I run `printf 'hello'`
+        And I run `printf 'goodbye'`
+        Then the stdout from "printf 'hello'" should contain "hello"
+        And the stdout from "printf 'hello'" should contain exactly "hello"
+        And the stdout from "printf 'hello'" should contain exactly:
+        \"\"\"
+        hello
+        \"\"\"
+        And the stderr from "printf 'hello'" should not contain "hello"
+        And the stdout from "printf 'goodbye'" should not contain "hello"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+

data/features/steps/filesystem/append_to_file.feature

@@ -0,0 +1,45 @@
+Feature: Append content to file
+
+  You might want to append some content to a file.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Append to a existing file
+    Given a file named "features/non-existence.feature" with:
+    """
+    Feature: Existence
+      Scenario: Existence
+        Given a file named "foo/bar/example.txt" with:
+        \"\"\"
+        hello world
+        \"\"\"
+        When I append to "foo/bar/example.txt" with:
+        \"\"\"
+        this was appended
+        \"\"\"
+        Then the file named "foo/bar/example.txt" should contain:
+        \"\"\"
+        hello worldthis was appended
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Append to a non-existing file
+    Given a file named "features/non-existence.feature" with:
+    """
+    Feature: Existence
+      Scenario: Existence
+        Given a file named "foo/bar/example.txt" does not exist
+        When I append to "foo/bar/example.txt" with:
+        \"\"\"
+        this was appended
+        \"\"\"
+        Then the file named "foo/bar/example.txt" should contain:
+        \"\"\"
+        this was appended
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass