aruba 0.14.14 → 1.0.0

data/features/04_aruba_api/text/unescape_text.feature

@@ -1,127 +0,0 @@
-Feature: Unescape special characters in text
-
-  If have got some text include \n, \t and the like and need them to become
-  special characters again, you can use the `#unescape_text`-method for this.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Output contains \n
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\ntext'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "text\ntext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \e
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\etext'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \"
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\"text'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "text\"text" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \033
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\033text'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \017
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\017text'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Output contains \016
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    echo -n 'text\016text'
-    """
-    And a file named "spec/unescape_text_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-
-      it { expect(unescape_text(last_command.output)).to eq "texttext" }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/05_use_rspec_matchers/command/check_timeouts.feature

@@ -1,48 +0,0 @@
-Feature: Check if a timeout occured during command execution
-
-  If you want to check if a command takes to long to finish it's work
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Check if command runs to long
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    sleep 1
-    """
-    And a file named "spec/timeout_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Long running command', :type => :aruba do
-      before(:each) { aruba.config.exit_timeout = 0 }
-
-      before(:each) { run_command('aruba-test-cli') }
-
-      it { expect(last_command_started).to run_too_long }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Check if command finishes in time
-    Given an executable named "bin/aruba-test-cli" with:
-    """
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/timeout_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Short running command', :type => :aruba do
-      before(:each) { aruba.config.exit_timeout = 5 }
-
-      before(:each) { run_command('aruba-test-cli') }
-
-      it { expect(last_command_started).to have_finished_in_time }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/05_use_rspec_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/05_use_rspec_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/05_use_rspec_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/05_use_rspec_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/05_use_rspec_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