aruba 0.14.9 → 1.0.0

data/features/hooks/before/command.feature

@@ -1,75 +0,0 @@
-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:
-    """
-    require 'aruba'
-
-    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_command_and_stop '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:
-    """
-    require 'aruba'
-
-    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_command_and_stop '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

@@ -1,72 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

data/features/matchers/file/be_existing_executable.feature

@@ -1,88 +0,0 @@
-Feature: Check if path exists and is an executable file
-
-  If you need to check if a given path exists and is a file, you can use the
-  `be_an_existing_executable`-matcher.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
-    let(:file) { 'file.txt' }
-    before(:each) { touch(file) }
-    before(:each) { chmod(0755, file) }
-
-    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 file exists and is an executable file', :type => :aruba do
-      let(:file) { 'file.txt' }
-      before(:each) { touch(file) }
-      before(:each) { chmod(0755, file) }
-
-      it { expect(file).to be_an_existing_executable }
-    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 file exists and is an executable file', :type => :aruba do
-      let(:file) { 'file.txt' }
-      it { expect(file).not_to be_an_existing_executable }
-    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.txt file2.txt) }
-
-      before :each do
-        files.each do |f|
-          touch(f)
-          chmod(0755, f)
-        end
-      end
-
-      it { expect(files).to all be_an_existing_executable }
-    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.txt file2.txt) }
-
-      before :each do
-        touch(files.first)
-        chmod(0755, files.first)
-      end
-
-      it { expect(files).to include an_existing_executable }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/matchers/file/be_existing_file.feature

@@ -1,82 +0,0 @@
-Feature: Check if path exists and is file
-
-  If you need to check if a given path exists and is a file, you can use the
-  `be_an_existing_file`-matcher.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if file exists and is file', :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 single existing file
-    Given a file named "spec/existing_file_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file exists and is file', :type => :aruba do
-      let(:file) { 'file.txt' }
-      before(:each) { touch(file) }
-      it { expect(file).to be_an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect single non-existing file
-    Given a file named "spec/existing_file_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file exists and is file', :type => :aruba do
-      let(:file) { 'file.txt' }
-      it { expect(file).not_to be_an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple existing files
-    Given a file named "spec/existing_file_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file exists and is file', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-
-      before :each do
-        files.each { |f| touch(f) }
-      end
-
-      it { expect(files).to all be_an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one existing file
-    Given a file named "spec/existing_file_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file exists and is file', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-
-      before :each do
-        touch(files.first)
-      end
-
-      it { expect(files).to include an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-

data/features/matchers/file/have_file_content.feature

@@ -1,123 +0,0 @@
-Feature: Check if file has content
-
-  If you need to check if a given file has content, you can use the
-  `have_file_content`-matcher. It accepts `Object`, `Regexp` or any other
-  `RSpec::Matcher`-matchers. It fails if file does not exist.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if file has content', :type => :aruba do
-    let(:file) { 'file.txt' }
-    let(:content) { 'Hello World' }
-
-    before(:each) { write_file(file, content) }
-
-    it { expect(file).to have_file_content content }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect existing file with content
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:content) { 'Hello World' }
-
-      before(:each) { write_file(file, content) }
-
-      it { expect(file).to have_file_content content }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect existing file with partial content
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:content) { 'Hello World' }
-
-      before(:each) { write_file(file, content) }
-
-      it { expect(file).to have_file_content /Hello/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect existing file with partial content described by another matcher
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:content) { 'Hello World' }
-
-      before(:each) { write_file(file, content) }
-
-      it { expect(file).to have_file_content a_string_starting_with('Hello') }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple existing files with content
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:content) { 'Hello World' }
-
-      before :each do
-        files.each { |f| write_file(f, content) }
-      end
-
-      it { expect(files).to all have_file_content content }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect at least one file with content
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:content) { 'Hello World' }
-
-      before(:each) { write_file(files.first, content) }
-
-      it { expect(files).to include a_file_having_content content }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Fails if file does not exist
-    Given a file named "spec/file_with_content_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check file content', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:content) { 'Hello World' }
-
-      it { expect(file).to have_file_content content }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass