aruba-win-fix 0.14.2

data/features/api/command/stop_all_commands.feature

@@ -0,0 +1,53 @@
+Feature: Stop all commands
+
+  To stop all running commands use the `#stop_all_commands`-method.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Multiple commands are running
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    sleep 3
+    """
+    And a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 5 do
+      before(:each) { run('cli') }
+      before(:each) { run('cli') }
+
+      before(:each) { stop_all_commands }
+
+      it { expect(all_commands).to all be_stopped }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Stop all commands for which the block returns true
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 2 do
+      before(:each) { @cmd1 = run('cli') }
+      before(:each) { @cmd2 = run('cli') }
+      before(:each) { @cmd3 = run('sleep 1') }
+
+      before(:each) { stop_all_commands { |c| c.commandline == 'cli' } }
+
+      it { expect(@cmd1).to be_stopped }
+      it { expect(@cmd2).to be_stopped }
+      it { expect(@cmd3).not_to be_stopped }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/command/terminate_all_commands.feature

@@ -0,0 +1,53 @@
+Feature: Terminate all commands
+
+  To terminate all running commands use the `#terminate_all_commands`-method.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Multiple commands are running
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    sleep 3
+    """
+    And a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 5 do
+      before(:each) { run('cli') }
+      before(:each) { run('cli') }
+
+      before(:each) { terminate_all_commands }
+
+      it { expect(all_commands).to all be_stopped }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Terminate all commands for which the block returns true
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    sleep 1
+    """
+    And a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 2 do
+      before(:each) { @cmd1 = run('cli') }
+      before(:each) { @cmd2 = run('cli') }
+      before(:each) { @cmd3 = run('sleep 1') }
+
+      before(:each) { terminate_all_commands { |c| c.commandline == 'cli' } }
+
+      it { expect(@cmd1).to be_stopped }
+      it { expect(@cmd2).to be_stopped }
+      it { expect(@cmd3).not_to be_stopped }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/command/which.feature

@@ -0,0 +1,37 @@
+Feature: Get path to command
+
+  Sometimes you only know a commands name, but not where to find it. Here comes
+  `which` to the rescue.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Existing executable
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "spec/which_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Find path for command', :type => :aruba do
+      it { expect(which('cli')).to match %r{tmp/aruba/cli-app/bin/cli} }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Non-existing executable
+    Given a file named "bin/cli" does not exist
+    And a file named "spec/which_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Find path for command', :type => :aruba do
+      it { expect(which('cli')).to be_nil }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/core/expand_path.feature

@@ -0,0 +1,88 @@
+Feature: Expand paths with aruba
+
+  There are quite a few uses cases why you want to expand a path. `aruba` helps
+  you with this by providing you the `expand_path`-method. This method expands
+  paths relative to the `aruba.current_directory`-directory.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Use relative path
+    Given a file named "spec/expand_path_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Expand path', :type => :aruba do
+      let(:path) { 'path/to/dir' }
+      it { expect(expand_path(path)).to eq File.join(aruba.root_directory, aruba.current_directory, path) }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Change directory using cd
+    Given a file named "spec/expand_path_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Expand path', :type => :aruba do
+      let(:path) { 'path/to/dir' }
+      let(:directory) { 'dir1' }
+
+      before(:each) { create_directory(directory) }
+      before(:each) { cd(directory) }
+
+      it { expect(expand_path(path)).to eq File.join(aruba.root_directory, aruba.current_directory, path) }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Warn if aruba's working directory does not exist
+    Given a file named "spec/expand_path_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Expand path', :type => :aruba do
+      before(:each) { remove('.') }
+
+      let(:path) { 'path/to/dir' }
+
+      it { expect { expand_path(path) }.to output(/working directory does not exist/).to_stderr }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Use ~ in path
+
+    Now this useses the HOME-variable from your normal shell HOME-variable.
+    From 1.0.0 on HOME will be `File.join(aruba.config.root_directory,
+    aruba.config.working_directory)`. If you want HOME have some other value,
+    you need to configure it explicitly via `Aruba.configure {}`.
+
+    Given a file named "spec/expand_path_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    # Old before 1.0.0
+    RSpec.describe 'Expand path', :type => :aruba do
+      let(:path) { '~/path/to/dir' }
+
+      it { expect(expand_path(path)).to match %r</home/[^/]+/path/to/dir> }
+    end
+
+    # New from 1.0.0
+    RSpec.describe 'Expand path', :type => :aruba do
+      let(:path) { '~/path/to/dir' }
+
+      before(:each) do
+        set_environment_variable('HOME', File.join(aruba.config.root_directory, aruba.config.working_directory))
+      end
+
+      it { expect(expand_path(path)).to eq File.join(aruba.config.root_directory, aruba.config.working_directory, 'path/to/dir') }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+

data/features/api/environment/append_environment_variable.feature

@@ -0,0 +1,128 @@
+Feature: Append environment variable
+
+  It is quite handy to modify the environment of a process. To make this
+  possible, `aruba` provides several methods. One of these is
+  `#append_environment_variable`. Using this variable appends a given value to
+  an existing one. If the variable does not exist, it is created with the given
+  value.
+
+  Each variable name and each value is converted to a string. Otherwise `ruby`
+  would complain about an invalid argument. To make use of a variable you can
+  either use `#run` and the like or `#with_environment`.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Non-existing variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Existing inner variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+      before(:each) { append_environment_variable 'LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=ab' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+
+  Scenario: Existing outer variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'REALLY_LONG_LONG_VARIABLE=ab' }
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with previously set environment
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it do
+        with_environment do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'ab'
+        end
+      end
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with local environment
+
+    If you pass the same variable to the block it will not be appended, but
+    overwrites the variable
+
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it do
+        with_environment 'REALLY_LONG_LONG_VARIABLE' => 'a' do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a'
+        end
+      end
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/environment/delete_environment_variable.feature

@@ -0,0 +1,63 @@
+Feature: Delete existing environment variable via API-method
+
+  It is quite handy to modify the environment of a process. To make this
+  possible, `aruba` provides several methods. One of these is
+  `#delete_environment_variable`. Using this remove an existing variable.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Non-existing variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { delete_environment_variable 'LONG_LONG_VARIABLE' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).not_to include 'LONG_LONG_VARIABLE=1' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Existing variable set from within the test
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '1' }
+      before(:each) { delete_environment_variable 'LONG_LONG_VARIABLE' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).not_to include 'LONG_LONG_VARIABLE' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Existing variable set by some outer parent process
+
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Environment command', :type => :aruba do
+      before(:each) { delete_environment_variable 'REALLY_LONG_LONG_VARIABLE' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).not_to include 'REALLY_LONG_LONG_VARIABLE' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/environment/prepend_environment_variable.feature

@@ -0,0 +1,128 @@
+Feature: Prepend environment variable
+
+  It is quite handy to modify the environment of a process. To make this
+  possible, `aruba` provides several methods. One of these is
+  `#prepend_environment_variable`. Using this variable prepends a given value to
+  an existing one. If the variable does not exist, it is created with the given
+  value.
+
+  Each variable name and each value is converted to a string. Otherwise `ruby`
+  would complain about an invalid argument. To make use of a variable you can
+  either use `#run` and the like or `#with_environment`.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Non-existing variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Existing inner variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+      before(:each) { prepend_environment_variable 'LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'LONG_LONG_VARIABLE=ba' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+
+  Scenario: Existing outer variable
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started.output).to include 'REALLY_LONG_LONG_VARIABLE=ba' }
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with previously set environment
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it do
+        with_environment do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'ba'
+        end
+      end
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with local environment
+
+    If you pass the same variable to the block it will not be prepended, but
+    overwrites the variable
+
+    Given a file named "spec/environment_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = 'a'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'REALLY_LONG_LONG_VARIABLE', 'b' }
+
+      before(:each) { run('env') }
+      before(:each) { stop_all_commands }
+
+      it do
+        with_environment 'REALLY_LONG_LONG_VARIABLE' => 'a' do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a'
+        end
+      end
+
+      # Has no effect here, is not in block and not a command `run`
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq 'a' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass