aruba-win-fix 0.14.2

data/features/getting_started/supported_testing_frameworks.feature

@@ -0,0 +1,104 @@
+Feature: Supported Testing Frameworks
+
+  You can use `aruba` with all major testing frameworks from the Ruby World:
+
+    \* Cucumber
+    \* RSpec
+    \* Minitest
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Use "aruba" with "Cucumber"
+    Given a file named "features/support/env.rb" with:
+    """
+    require 'aruba/cucumber'
+    """
+    And a file named "features/use_aruba_with_cucumber.feature" with:
+    """
+    Feature: Cucumber
+      Scenario: First Run
+        Given a file named "file.txt" with:
+        \"\"\"
+        Hello World
+        \"\"\"
+        Then the file "file.txt" should contain:
+        \"\"\"
+        Hello World
+        \"\"\"
+    """
+    When I run `cucumber`
+    Then the features should all pass
+
+  Scenario: Use "aruba" with "RSpec"
+    Given a file named "spec/support/aruba.rb" with:
+    """
+    require 'aruba/rspec'
+    """
+    And a file named "spec/spec_helper.rb" with:
+    """
+    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+    if RUBY_VERSION < '1.9.3'
+      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
+    else
+      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
+    end
+    """
+    And a file named "spec/use_aruba_with_rspec_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'First Run', :type => :aruba do
+      let(:file) { 'file.txt' }
+      let(:content) { 'Hello World' }
+
+      before(:each) { write_file file, content }
+
+      it { expect(read(file)).to eq [content] }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+
+  Scenario: Use "aruba" with "Minitest"
+    Given a file named "test/support/aruba.rb" with:
+    """
+    require 'aruba/api'
+    """
+    And a file named "test/test_helper.rb" with:
+    """
+    $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+    if RUBY_VERSION < '1.9.3'
+      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
+    else
+      ::Dir.glob(::File.expand_path('../support/**/*.rb', __FILE__)).each { |f| require_relative f }
+    end
+    """
+    And a file named "test/use_aruba_with_minitest.rb" with:
+    """
+    $LOAD_PATH.unshift File.expand_path('../test', __FILE__)
+
+    require 'test_helper'
+    require 'minitest/autorun'
+
+    class FirstRun < Minitest::Test
+      include Aruba::Api
+
+      def setup
+        aruba_setup
+      end
+
+      def getting_started_with_aruba
+        file = 'file.txt'
+        content = 'Hello World' 
+
+        write_file file, content
+        read(file).must_equal [content]
+      end
+    end
+    """
+    When I run `ruby -Ilib:test test/use_aruba_with_minitest.rb`
+    Then the tests 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

@@ -0,0 +1,44 @@
+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"
+
+  Scenario: Run a simple command with an "after(:command)"-hook
+    Given a file named "spec/support/hooks.rb" with:
+    """
+    Aruba.configure do |config|
+      config.after :command do |cmd|
+        puts "after the run of `#{cmd.commandline}`"
+      end
+    end
+    """
+    And a file named "spec/hook_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Hooks', :type => :aruba do
+      before(:each) { run_simple 'echo running' }
+
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+    And the output should contain:
+    """
+    after the run of `echo running`
+    """
+

data/features/hooks/before/command.feature

@@ -0,0 +1,71 @@
+Feature: before_cmd hooks
+
+  You can configure Aruba to run blocks of code before it runs
+  each 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.before :command do |cmd|
+      puts "About to run '#{cmd}'"
+    end
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Run a simple command with a "before(:command)"-hook
+    Given a file named "spec/support/hooks.rb" with:
+    """
+    Aruba.configure do |config|
+      config.before :command do |cmd|
+        puts "before the run of `#{cmd.commandline}`"
+      end
+    end
+    """
+    And a file named "spec/hook_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Hooks', :type => :aruba do
+      before(:each) { run_simple 'echo running' }
+
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+    And the output should contain:
+    """
+    before the run of `echo running`
+    """
+
+  Scenario: Run a simple command with a "before(:cmd)"-hook (deprecated)
+    Given a file named "spec/support/hooks.rb" with:
+    """
+    Aruba.configure do |config|
+      config.before :cmd do |cmd|
+        puts "before the run of `#{cmd}`"
+      end
+    end
+    """
+    And a file named "spec/hook_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Hooks', :type => :aruba do
+      before(:each) { run_simple 'echo running' }
+
+      it { expect(last_command_started.stdout.chomp).to eq 'running' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+    And the output should contain:
+    """
+    before the run of `echo running`
+    """

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/directory/have_sub_directory.feature

@@ -0,0 +1,110 @@
+Feature: Check if directory has given sub directories
+
+  If you need to check if a given directory has given sub dirctories, you can
+  use the `have_sub_directory`-matcher.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+    let(:file) { 'file.txt' }
+    before(:each) { touch(file) }
+
+    it { expect(file).to be_an_existing_file }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect existing sub directory
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      let(:sub_directory) { 'sub-dir.d' }
+
+      before(:each) { create_directory(File.join(directory, sub_directory)) }
+
+      it { expect(directory).to have_sub_directory sub_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing sub directories
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      let(:sub_directories) { %w(sub-dir1.d sub-dir2.d) }
+
+      before(:each) do
+        sub_directories.each { |d| create_directory(File.join(directory, d)) }
+      end
+
+      it { expect(directory).to have_sub_directory sub_directories }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect non-existing sub directory
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+      let(:directory) { 'dir.d' }
+      let(:sub_directory) { 'sub-dir.d' }
+
+      before(:each) { create_directory(directory) }
+
+      it { expect(directory).not_to have_sub_directory sub_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple directories have sub directory
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+      let(:directories) { %w(dir1.d dir2.d) }
+      let(:sub_directory) { 'sub-dir.d' }
+
+      before(:each) do
+        directories.each { |d| create_directory(File.join(d, sub_directory)) }
+      end
+
+      it { expect(directories).to all have_sub_directory sub_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one directory has sub directory
+    Given a file named "spec/existing_file_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if directory has sub-directory', :type => :aruba do
+      let(:directories) { %w(dir1.d dir2.d) }
+      let(:sub_directory) { 'sub-dir.d' }
+
+      before(:each) do
+        create_directory(File.join(directories.first, sub_directory))
+      end
+
+      it { expect(directories).to include a_directory_having_sub_directory sub_directory }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+

data/features/matchers/file/be_a_command_found_in_path.feature

@@ -0,0 +1,115 @@
+Feature: Check if command can be found in PATH
+
+  If you need to check if a given command can be found in path, you can use the
+  `be_an_existing_executable`-matcher.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if command can be found in PATH', :type => :aruba do
+    let(:file) { 'file.sh' }
+    before(:each) { touch(file) }
+    before(:each) { chmod(0755, file) }
+    before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.')) }
+
+    it { expect(file).to be_an_existing_executable }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect single existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if command can be found in PATH', :type => :aruba do
+      let(:file) { 'file.sh' }
+
+      before(:each) { touch(file) }
+      before(:each) { chmod(0755, file) }
+      before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.'))) }
+
+      it { expect(file).to be_a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if command can be found in PATH', :type => :aruba do
+      let(:file) { 'file.sh' }
+
+      before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.'))) }
+
+      it { expect(file).not_to be_a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if command can be found in PATH', :type => :aruba do
+      let(:file) { 'file.sh' }
+
+      before(:each) { touch(file) }
+      before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.'))) }
+
+      it { expect(file).not_to be_a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing executable files
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.sh file2.sh) }
+
+      before :each do
+        files.each do |f|
+          touch(f)
+          chmod(0755, f)
+        end
+      end
+
+      before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.'))) }
+
+      it { expect(files).to all be_a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.sh file2.sh) }
+
+      before :each do
+        touch(files.first)
+        chmod(0755, files.first)
+      end
+
+      before(:each) { prepend_environment_variable('PATH', format('%s:', expand_path('.'))) }
+
+      it { expect(files).to include a_command_found_in_path }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass