aruba 0.9.0.pre → 0.9.0.pre2

data/features/file_system_commands.feature

@@ -4,18 +4,18 @@ Feature: file system commands
   As a developer using Cucumber
   I want to create temporary files
 
-  Scenario: create a dir
-    Given a directory named "foo/bar"
-    When I run `file foo/bar`
-    Then the stdout should contain "foo/bar: directory"
-
-  Scenario: create a file
-    Given a file named "foo/bar/example.txt" with:
-      """
-      hello world
-      """
-    When I run `cat foo/bar/example.txt`
-    Then the output should contain exactly "hello world"
+  # Scenario: create a dir
+  #   Given a directory named "foo/bar"
+  #   When I run `file foo/bar`
+  #   Then the stdout should contain "foo/bar: directory"
+
+  # Scenario: create a file
+  #   Given a file named "foo/bar/example.txt" with:
+  #     """
+  #     hello world
+  #     """
+  #   When I run `cat foo/bar/example.txt`
+  #   Then the output should contain exactly "hello world"
 
   Scenario: a file does not exist
     Given a file named "example.txt" does not exist

data/features/getting_started/supported_programming_languages.feature

@@ -0,0 +1,89 @@
+Feature: Supported programming languages
+
+  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. 
+
+  Below you find some examples of the "Hello, Aruba!"-application implemented
+  with different programming languages. 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: 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: 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: 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: 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

data/features/hooks/after/command.feature

@@ -22,7 +22,7 @@ Feature: After command hooks
     RSpec.describe 'Hooks', :type => :aruba do
       before(:each) { run_simple 'echo running' }
 
-      it { expect(last_command.stdout.chomp).to eq 'running' }
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
     end
     """
     When I run `rspec`

data/features/hooks/before/command.feature

@@ -24,7 +24,7 @@ Feature: before_cmd hooks
     RSpec.describe 'Hooks', :type => :aruba do
       before(:each) { run_simple 'echo running' }
 
-      it { expect(last_command.stdout.chomp).to eq 'running' }
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
     end
     """
     When I run `rspec`
@@ -50,7 +50,7 @@ Feature: before_cmd hooks
     RSpec.describe 'Hooks', :type => :aruba do
       before(:each) { run_simple 'echo running' }
 
-      it { expect(last_command.stdout.chomp).to eq 'running' }
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
     end
     """
     When I run `rspec`

data/features/matchers/collection/include_an_object.feature

@@ -0,0 +1,72 @@
+Feature: `include_an_object` Matcher
+
+  Use the `include_an_object` matcher to specify that a collection's objects include_an_object pass an expected matcher.
+  This works on include_an_object enumerable object.
+
+    ```ruby
+    expect([1, 4, 5]).to include_an_object( be_odd )
+    expect([1, 3, 'a']).to include_an_object( be_an(Integer) )
+    expect([1, 3, 11]).to include_an_object( be < 10 )
+    ```
+
+  The matcher also supports compound matchers:
+
+    ```ruby
+    expect([1, 'a', 11]).to include_an_object( be_odd.and be < 10 )
+    ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Array usage
+    Given a file named "spec/array_include_an_object_matcher_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      RSpec.describe [1, 4, 'a', 11] do
+        it { is_expected.to include_an_object( be_odd ) }
+        it { is_expected.to include_an_object( be_an(Integer) ) }
+        it { is_expected.to include_an_object( be < 10 ) }
+        it { is_expected.not_to include_an_object( eq 'b' ) }
+      end
+
+      RSpec.describe [14, 'a'] do
+        it { is_expected.to include_an_object( be_odd ) }
+        it { is_expected.to include_an_object( be_an(Symbol) ) }
+        it { is_expected.to include_an_object( be < 10 ) }
+        it { is_expected.not_to include_an_object( eq 'a' ) }
+      end
+      """
+    When I run `rspec`
+    Then the output should contain all of these lines:
+      | 8 examples, 4 failures                                      |
+      | expected [14, "a"] to include an object be odd              |
+      | expected [14, "a"] to include an object be a kind of Symbol |
+      | expected [14, "a"] to include an object be < 10             |
+      | expected [14, "a"] not to include an object eq "a"          |
+
+  Scenario: Compound Matcher Usage
+    Given a file named "spec/compound_include_an_object_matcher_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      RSpec.describe [1, 'anything', 'something'] do
+        it { is_expected.to include_an_object( be_a(String).and include("thing") ) }
+        it { is_expected.to include_an_object( be_a(String).and end_with("g") ) }
+        it { is_expected.to include_an_object( start_with("s").or include("y") ) }
+        it { is_expected.not_to include_an_object( start_with("b").or include("b") ) }
+      end
+
+      RSpec.describe ['anything', 'something'] do
+        it { is_expected.to include_an_object( be_a(Integer).and include("thing") ) }
+        it { is_expected.to include_an_object( be_a(Integer).and end_with("z") ) }
+        it { is_expected.to include_an_object( start_with("z").or include("1") ) }
+        it { is_expected.not_to include_an_object( start_with("a").or include("some") ) }
+      end
+      """
+    When I run `rspec`
+    Then the output should contain all of these lines:
+      | 8 examples, 4 failures                                                                           |
+      | expected ["anything", "something"] to include an object be a kind of Integer and include "thing" |
+      | expected ["anything", "something"] to include an object be a kind of Integer and end with "z"    |
+      | expected ["anything", "something"] to include an object start with "z" or include "1"            |

data/features/matchers/timeouts.feature

@@ -20,7 +20,7 @@ Feature: Check if a timeout occured during command execution
 
       before(:each) { run('cli') }
 
-      it { expect(last_command).to run_too_long }
+      it { expect(last_command_started).to run_too_long }
     end
     """
     When I run `rspec`
@@ -41,7 +41,7 @@ Feature: Check if a timeout occured during command execution
 
       before(:each) { run('cli') }
 
-      it { expect(last_command).to have_finished_in_time }
+      it { expect(last_command_started).to have_finished_in_time }
     end
     """
     When I run `rspec`

data/features/output.feature

@@ -1,184 +1,47 @@
-Feature: Output
+Feature: All output 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
 
-  @posix
-  Scenario: Detect subset of one-line output
-    When I run `printf 'hello world'`
-    Then the output should contain "hello world"
+  Background:
+    Given I use a fixture named "cli-app"
+
+  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 absence of one-line output
-    When I run `printf "hello world"`
-    Then the output should not contain "good-bye"
-
-  Scenario: Detect subset of multiline output
-    When I run `printf "hello\nworld"`
-    Then the output should contain:
-      """
-      hello
-      """
-
-  Scenario: Detect absence of multiline output
-    When I run `printf "hello\nworld"`
-    Then the output should not contain:
-      """
-      good-bye
-      """
-
-  @posix
-  Scenario: Detect exact one-line output
-    When I run `printf "hello world"`
-    Then the output should contain exactly:
-      """
-      hello world
-      """
-
-  @ansi
-  @posix
-  Scenario: Detect exact one-line output with ANSI output
-    When I run `printf "\e[36mhello world\e[0m"`
-    Then the output should contain exactly:
-      """
-      \e[36mhello world\e[0m
-      """
-
-  @posix
-  Scenario: Detect exact one-line output with ANSI output stripped by default
-    When I run `printf "\e[36mhello world\e[0m"`
-    Then the output should contain exactly:
-      """
-      hello world
-      """
-
-  @posix
-  Scenario: Detect exact multiline output
-    When I run `printf "hello\nworld"`
-    Then the output should contain exactly:
-      """
-      hello
-      world
-      """
-
-  @announce
-  Scenario: Detect subset of one-line output with regex
-    When I run `printf "hello, ruby"`
-    Then the output should contain "ruby"
-    And the output should match /^hello(, world)?/
-
-  @announce
-  @posix
-  Scenario: Detect subset of multiline output with regex
-    When I run `printf "hello\nworld\nextra line1\nextra line2\nimportant line"`
-    Then the output should match:
-      """
-      he..o
-      wor.d
-      .*
-      important line
-      """
-
-  @announce
-  Scenario: Negative matching of one-line output with regex
-    When I run `printf "hello, ruby"`
-    Then the output should contain "ruby"
-    And the output should not match /ruby is a better perl$/
-
-  @announce
-  @posix
-  Scenario: Negative matching of multiline output with regex
-    When I run `printf "hello\nworld\nextra line1\nextra line2\nimportant line"`
-    Then the output should not match:
-      """
-      ruby
-      is
-      a
-      .*
-      perl
-      """
-
-  @announce
-  @posix
-  Scenario: Match passing exit status and partial output
-    When I run `printf "hello\nworld"`
-    Then it should pass with:
-      """
-      hello
-      """
-
-  @posix
-  Scenario: Match passing exit status and exact output
-    When I run `printf "hello\nworld"`
-    Then it should pass with exactly:
-      """
-      hello
-      world
-      """
-
-  @announce-stdout
-  Scenario: Match failing exit status and partial output
-    When I run `bash -c '(printf "hello\nworld";exit 99)'`
-    Then it should fail with:
-      """
-      hello
-      """
-
-  @posix
-  Scenario: Match failing exit status and exact output
-    When I run `bash -c '(printf "hello\nworld";exit 99)'`
-    Then it should fail with exactly:
-      """
-      hello
-      world
-      """
-
-  @announce-stdout
-  @posix
-  Scenario: Match failing exit status and output with regex
-    When I run `bash -c '(printf "hello\nworld";exit 99)'`
-    Then it should fail with regex:
-      """
-      hello\s*world
-      """
-
-  @announce-cmd
-  @posix
-  Scenario: Match output in stdout
-    When I run `printf "hello\nworld"`
-    Then the stdout should contain "hello"
-    Then the stderr should not contain "hello"
-
-  @announce
-  Scenario: Match output on several lines
-    When I run `printf 'GET /'`
-    Then the stdout should contain:
-      """
-      GET /
-      """
-
-  @posix
-  Scenario: Match output on several lines using quotes
-    When I run `printf 'GET "/"'`
-    Then the stdout should contain:
-      """
-      GET "/"
-      """
-
-  @posix
-  Scenario: Detect output from all processes
-    When I run `printf "hello world!\n"`
-    And I run `cat` interactively
-    And I type "hola"
-    And I type ""
-    Then the output should contain exactly:
-      """
-      hello world!
-      hola
-
-      """
-
-  @posix
   Scenario: Detect stdout from all processes
     When I run `printf "hello world!\n"`
     And I run `cat` interactively
@@ -187,22 +50,38 @@ Feature: Output
     Then the stdout should contain:
       """
       hello world!
+      """
+    And the stdout should contain:
+      """
       hola
-
       """
     And the stderr should not contain anything
 
-  @posix
   Scenario: Detect stderr from all processes
     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
-      """
+    """
+    hello world!
+    """
+    And the stderr should contain:
+    """
+    hola
+    """
+    And the stdout should not contain anything
+
+  Scenario: Detect stderr from all processes (deprecated)
+    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
 
   Scenario: Detect output from named source