aruba-win-fix 0.14.2

data/features/matchers/path/be_an_existing_path.feature

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

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

@@ -0,0 +1,48 @@
+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('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('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

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

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