aruba 0.14.9 → 1.0.0

data/features/matchers/file/have_file_size.feature

@@ -1,107 +0,0 @@
-Feature: Check if path has size
-
-  If you need to check if a given path has file size, you can use the
-  `have_file_size`-matcher. It fails if the file does not exist.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if file has size', :type => :aruba do
-    let(:file) { 'file.txt' }
-    let(:size) { 1 }
-
-    before(:each) { write_fixed_size_file(file, size) }
-
-    it { expect(file).to have_file_size size }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect file of given size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      before(:each) { write_fixed_size_file(file, size) }
-
-      it { expect(file).to have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple files of given size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:size) { 1 }
-
-      before :each do
-        files.each { |f| write_fixed_size_file(f, size) }
-      end
-
-      it { expect(files).to all have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one file of size
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:size) { 1 }
-
-      before :each do
-        write_fixed_size_file(files.first, size)
-      end
-
-      it { expect(files).to include a_file_of_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Fails because file has different size than expected
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      before(:each) { write_fixed_size_file(file, size) }
-
-      it { expect(file).to have_file_size 2 }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass
-
-  Scenario: Fails if file does not exist
-    Given a file named "spec/file_of_size_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if file has size', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:size) { 1 }
-
-      it { expect(file).to have_file_size size }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/matchers/path/be_an_absolute_path.feature

@@ -1,74 +0,0 @@
-Feature: Check if path is absolute
-
-  If you need to check if a given path is absolute , you can use the
-  `be_an_absolute_path`-matcher. It doesn't care if the path is a directory or
-  a path.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path is absolute', :type => :aruba do
-    let(:path) { 'file.txt' }
-    before(:each) { touch(path) }
-
-    it { expect(path).to be_an_absolute_path }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect single existing path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:path) { '/path/to/file.txt' }
-      it { expect(path).to be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple absolute paths
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(/path/to/path1.txt /path/to/path2.txt) }
-
-      it { expect(paths).to all be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one existing path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(/path/to/path1.txt path2.txt) }
-
-      it { expect(paths).to include an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect failure on relative path
-    Given a file named "spec/absolute_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path is absolute', :type => :aruba do
-      let(:paths) { %w(path2.txt) }
-
-      it { expect(paths).to be_an_absolute_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/matchers/path/be_an_existing_path.feature

@@ -1,97 +0,0 @@
-Feature: Check if path exists
-
-  If you need to check if a given path exists, you can use the
-  `be_an_existing_path`-matcher. It doesn't care if the path is a directory or
-  a path.
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path exists', :type => :aruba do
-    let(:path) { 'file.txt' }
-    before(:each) { touch(path) }
-
-    it { expect(path).to be_an_existing_path }
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect single existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'file.txt' }
-      before(:each) { touch(path) }
-      it { expect(path).to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect single existing directory
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'dir.d' }
-      before(:each) { create_directory(path) }
-      it { expect(path).to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect single non-existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:path) { 'file.txt' }
-      it { expect(path).not_to be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple existing paths
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:paths) { %w(path1.txt path2.txt) }
-
-      before :each do
-        paths.each { |f| touch(f) }
-      end
-
-      it { expect(paths).to all be_an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one existing path
-    Given a file named "spec/existing_path_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path exists', :type => :aruba do
-      let(:paths) { %w(path1.txt path2.txt) }
-
-      before :each do
-        touch(paths.first)
-      end
-
-      it { expect(paths).to include an_existing_path }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-

data/features/matchers/path/have_permissions.feature

@@ -1,118 +0,0 @@
-Feature: Check if path has permissions in filesystem
-
-  If you need to check if a given path has some permissions in filesystem, you
-  can use the `have_permissions`-matcher. It fails if the file or directory
-  does not exist. You need to pass it the permissions either as `Octal`
-  (`0700`) or `String` (`'0700'`).
-
-  ```ruby
-  require 'spec_helper'
-
-  RSpec.describe 'Check if path has permissions', :type => :aruba do
-    context 'when is file' do
-      let(:file) { 'file.txt' }
-      let(:permissions) { 0700 }
-
-      before(:each) { touch(file) }
-      before(:each) { chmod(permissions, file }
-
-      it { expect(file).to have_permissions permissions }
-    end
-  end
-  ```
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Expect file with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:file) { 'file.txt' }
-      let(:permissions) { 0700 }
-
-      before(:each) { touch(file) }
-      before(:each) { chmod(permissions, file) }
-
-      it { expect(file).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect directory with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:directory) { 'directory.d' }
-      let(:permissions) { 0700 }
-
-      before(:each) { create_directory(directory) }
-      before(:each) { chmod(permissions, directory) }
-
-      it { expect(directory).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect multiple files with given permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:permissions) { 0700 }
-
-      before :each do
-        files.each do |f|
-          touch(f)
-          chmod(permissions, f)
-        end
-      end
-
-      it { expect(files).to all have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Expect a least one file with permissions
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:files) { %w(file1.txt file2.txt) }
-      let(:permissions) { 0700 }
-
-      before :each do
-        touch(files.first)
-        chmod(permissions, files.first)
-      end
-
-      it { expect(files).to include a_path_having_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Fails if path does not exist
-    Given a file named "spec/path_with_permissions_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Check if path has permissions', :type => :aruba do
-      let(:path) { 'file.txt' }
-      let(:permissions) { 0777 }
-
-      it { expect(path).to have_permissions permissions }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not all pass

data/features/matchers/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/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('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/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('cli') }
-
-      it { expect(last_command_started).to have_finished_in_time }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/platforms/jruby.feature

@@ -1,14 +0,0 @@
-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/rspec/integration.feature

@@ -1,179 +0,0 @@
-Feature: Getting started with RSpec and aruba
-
-  Background:
-    Given I use the fixture "empty-app"
-
-  Scenario: Simple Integration
-
-    To use the simple integration just require `aruba/rspec` in your
-    `spec_helper.rb`. After that you only need to flag your tests with `type:
-    :aruba` and some things are set up for.
-
-    The simple integration adds some `before(:each)`-hooks for you:
-
-      \* Setup Aruba Test directory
-      \* Clear environment (ENV)
-      \* Make HOME-variable configarable via `arub.config.home_directory`
-      \* Configure `aruba` via `RSpec`-metadata
-      \* Activate announcers based on `RSpec`-metadata
-
-    Be careful, if you are going to use a `before(:all)`-hook to set up
-    files/directories. Those will be deleted by the `setup_aruba`-call within
-    the `before(:each)`-hook. Look for some custom integration further down the
-    documentation for a solution.
-
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    require 'aruba/rspec'
-    """
-    And a file named "spec/getting_started_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Integrate Aruba into RSpec', :type => :aruba do
-      context 'when to be or not be...' do
-        it { expect(aruba).to be }
-      end
-
-      context 'when write file' do
-        let(:file) { 'file.txt' }
-
-        before(:each) { write_file file, 'Hello World' }
-
-        it { expect(file).to be_an_existing_file }
-        it { expect([file]).to include an_existing_file }
-      end
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Simple Custom Integration
-
-    There might be some use cases where you want to build an aruba integration
-    of your own. You need to include the API and make sure, that you run
-
-      \* `restore_env` (only for aruba < 1.0.0)
-      \* `setup_aruba`
-
-    before any method of aruba is used.
-
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    require 'aruba/api'
-
-    RSpec.configure do |config|
-      config.include Aruba::Api
-    end
-    """
-    And a file named "spec/getting_started_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Custom Integration of aruba' do
-      let(:file) { 'file.txt' }
-
-      before(:each) { setup_aruba }
-      before(:each) { write_file file, 'Hello World' }
-
-      it { expect(file).to be_an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Custom Integration using before(:all)-hook
-
-    You can even use `aruba` within a `before(:all)`-hook. But again, make sure
-    that `setup_aruba` is run before you use any method of `aruba`. Using
-    `setup_aruba` both in `before(:all)`- and `before(:each)`-hook is not
-    possible and therefor not supported:
-
-    Running `setup_aruba` removes `tmp/aruba`, creates a new one `tmp/aruba`
-    and make it the working directory. Running it within a `before(:all)`-hook,
-    run some `aruba`-method and then run `setup_arub` again within a
-    `before(:each)`-hook, will remove the files/directories created within the
-    `before(:all)`-hook.
-
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    require 'aruba/api'
-
-    RSpec.configure do |config|
-      config.include Aruba::Api
-    end
-    """
-    And a file named "spec/getting_started_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Custom Integration of aruba' do
-      before(:all) { setup_aruba }
-      before(:all) { write_file 'file.txt', 'Hello World' }
-
-      it { expect('file.txt').to be_an_existing_file }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Setup aruba before use any of it's methods
-
-    From 1.0.0 it will be required, that you setup aruba before you use it.
-
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    require 'aruba/api'
-
-    RSpec.configure do |config|
-      config.include Aruba::Api
-    end
-    """
-    And a file named "spec/getting_started_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Custom Integration of aruba' do
-      let(:file) { 'file.txt' }
-
-      before(:each) { setup_aruba }
-
-      it { expect(true).to be true }
-    end
-    """
-    And an empty file named "tmp/aruba/garbage.txt"
-    When I run `rspec`
-    Then the specs should all pass
-    And the file "tmp/aruba/garbage.txt" should not exist anymore
-
-  Scenario: Fail-safe use if "setup_aruba" is not used
-
-    If you forgot to run `setup_aruba` before the first method of aruba is
-    used, you might see an error. Although we did our best to prevent this.
-
-    Make sure that you run `setup_aruba` before any method of aruba is used. At
-    best before each and every test.
-
-    This will be not supported anymore from 1.0.0 on.
-
-    Given a file named "spec/spec_helper.rb" with:
-    """
-    require 'aruba/api'
-
-    RSpec.configure do |config|
-      config.include Aruba::Api
-    end
-    """
-    And a file named "spec/getting_started_spec.rb" with:
-    """
-    require 'spec_helper'
-
-    RSpec.describe 'Custom Integration of aruba' do
-      let(:file) { 'file.txt' }
-
-      it { expect { write_file file, 'Hello World' }.not_to raise_error }
-      it { expect(aruba.current_directory.directory?).to be true }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/step_definitions/aruba_dev_steps.rb

@@ -1,56 +0,0 @@
-When /^I do aruba (.*)$/ do |aruba_step|
-  @aruba_exception = StandardError.new
-
-  begin
-    step(aruba_step)
-  rescue => e
-    @aruba_exception = e
-  end
-end
-
-# Useful for debugging timing problems
-When /^sleep (\d+)$/ do |time|
-  sleep time.to_i
-end
-
-When /^I set env variable "(\w+)" to "([^"]*)"$/ do |var, value|
-  ENV[var] = value
-end
-
-Then /^aruba should fail with "([^"]*)"$/ do |error_message|
-  expect(@aruba_exception.message).to include sanitize_text(error_message)
-end
-
-Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
-  expect{steps multiline_step.to_s}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-end
-
-Given(/^the default executable$/) do
-  step 'an executable named "bin/cli" with:', <<-EOS
-#!/usr/bin/env ruby
-
-$LOAD_PATH << File.expand_path('../../lib', __FILE__)
-require 'cli/app'
-
-exit 0
-  EOS
-end
-
-Given(/^the default feature-test$/) do
-  step(
-    'a file named "features/default.feature" with:',
-    <<-EOS.strip_heredoc
-    Feature: Default Feature
-
-      This is the default feature
-
-      Scenario: Run command
-        Given I successfully run `cli`
-    EOS
-  )
-end
-
-Then(/^aruba should be installed on the local system$/) do
-  run_command('gem list aruba')
-  expect(last_command_started).to have_output(/aruba/)
-end