aruba 0.7.4 → 0.8.0.pre

data/features/api/command/run.feature

@@ -0,0 +1,37 @@
+Feature: Run command
+
+  To run a command use the `#run`-method.
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Existing executable
+    Given an executable named "bin/cli" with:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "spec/which_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('cli') }
+      it { expect(last_command).to be_successfully_executed }
+    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:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Find path for command', :type => :aruba do
+      it { expect { run('cli') }.to raise_error Aruba::LaunchError, /Command "cli" not found in PATH-variable/ }
+    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:
+    """
+    #!/bin/bash
+    exit 0
+    """
+    And a file named "spec/which_spec.rb" with:
+    """
+    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:
+    """
+    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/environment/append_environment_variable.feature

@@ -0,0 +1,118 @@
+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:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { append_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+      before(:each) { run('env') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      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:
+    """
+    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') }
+
+      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/prepend_environment_variable.feature

@@ -0,0 +1,118 @@
+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:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { prepend_environment_variable 'LONG_LONG_VARIABLE', 'a' }
+      before(:each) { run('env') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      it { expect(last_command.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:
+    """
+    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') }
+
+      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:
+    """
+    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') }
+
+      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/set_environment_variable.feature

@@ -0,0 +1,252 @@
+Feature: Set 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
+  `#set_environment_variable`. Using this variable sets the value of a
+  non-existing variable and overwrites an existing 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`. Besides setting a variable globally, you
+  can set one for a block of code only using `#with_environment`.
+
+  Background:
+    Given I use the fixture "cli-app"
+
+  Scenario: Non-existing variable
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '1' }
+      before(:each) { run('env') }
+
+      it { expect(last_command.output).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:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '1' }
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '2' }
+      before(:each) { run('env') }
+
+      it { expect(last_command.output).to include 'LONG_LONG_VARIABLE=2' }
+    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:
+    """
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'REALLY_LONG_LONG_VARIABLE', '2' }
+      before(:each) { run('env') }
+
+      it { expect(last_command.output).to include 'REALLY_LONG_LONG_VARIABLE=2' }
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code in code with previously set environment
+
+    The `#with_environment`-block makes the change environment temporary
+    avaiable for the code run within the block.
+
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'REALLY_LONG_LONG_VARIABLE', '2' }
+      before(:each) { run('env') }
+
+      it do
+        with_environment do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '2'
+        end
+      end
+
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with local environment
+
+    If you need to set some environment variables only for the given block.
+    Pass it an `Hash` containing the environment variables.
+
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'REALLY_LONG_LONG_VARIABLE', '2' }
+      before(:each) { run('env') }
+
+      it do
+        with_environment 'REALLY_LONG_LONG_VARIABLE' => '3' do
+          expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '3'
+        end
+      end
+
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Nested setup with rspec
+
+    It doesn't matter if you define an environment variable in some outer
+    scope, when you are using `RSpec`.
+
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '1' }
+
+      describe 'Method XX' do
+        before(:each) { run('env') }
+
+        it { expect(last_command.output).to include 'LONG_LONG_VARIABLE=1' }
+      end
+
+      describe 'Method YY' do
+        before(:each) { set_environment_variable 'LONG_LONG_VARIABLE', '2' }
+        before(:each) { run('env') }
+
+        it { expect(last_command.output).to include 'LONG_LONG_VARIABLE=2' }
+      end
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: When an error occures the ENV is not polluted
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      before(:each) { set_environment_variable 'REALLY_LONG_LONG_VARIABLE', '2' }
+      before(:each) { run('env') }
+
+      it do
+        begin
+          with_environment 'REALLY_LONG_LONG_VARIABLE' => '3' do
+            fail
+          end
+        rescue StandardError
+        end
+
+        expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1'
+      end
+
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Run some ruby code with nested environment blocks
+
+    It is possible to use a `#with_environment`-block with a
+    `#with_environment`-block. Each previously set variable is available with
+    the most inner block.
+
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    ENV['LONG_LONG_VARIABLE'] = '1'
+    ENV['REALLY_LONG_LONG_VARIABLE'] = '1'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      it do
+        with_environment 'REALLY_LONG_LONG_VARIABLE' => 2 do
+          with_environment 'LONG_LONG_VARIABLE' => 3 do
+            expect(ENV['LONG_LONG_VARIABLE']).to eq '3'
+            expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '2'
+          end
+        end
+      end
+
+      it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Re-use `#with_environment` for multiple `RSpec`-`it`-blocks
+
+    If you chose to run wrap examples via `RSpec`'s `around`-hook, make sure you
+    use `before(:context) {}` instead of `before(:each)` to set an environment
+    variable. Only then the `before`-hook is run before the `around`-hook is
+    run.
+
+    Given a file named "spec/environment_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Long running command', :type => :aruba do
+      # Please mind :context. This is run BEFORE the `around`-hook
+      before(:context) { set_environment_variable 'REALLY_LONG_LONG_VARIABLE', '1' }
+
+      context 'when no arguments are given' do
+        around(:each) do |example|
+          with_environment do
+            example.run
+          end
+        end
+
+        it { expect(ENV['REALLY_LONG_LONG_VARIABLE']).to eq '1' }
+
+        before(:each) { run('env') }
+
+        it { expect(last_command.output).to include 'REALLY_LONG_LONG_VARIABLE=1' }
+      end
+
+      context 'when arguments given' do
+        around(:each) do |example|
+          with_environment 'LONG_LONG_VARIABLE' => 2 do
+            example.run
+          end
+        end
+
+        it { expect(ENV['LONG_LONG_VARIABLE']).to eq '2' }
+
+        before(:each) { run('env') }
+
+        it { expect(last_command.output).to include 'REALLY_LONG_LONG_VARIABLE=1' }
+      end
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass