aruba 0.14.14 → 1.0.0.pre.alpha.1

data/features/04_aruba_api/command/find_a_started_command.feature

@@ -1,83 +0,0 @@
-Feature: Find a started command
-
-  This feature is experimental and may change without further notice.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Existing command
-    Given a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('echo hello') }
-      let(:command) { find_command('echo hello') }
-
-      before(:each) { stop_all_commands }
-
-      it { expect(command).to be_successfully_executed }
-      it { expect(command.commandline).to eq 'echo hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Non-Existing command
-    Given a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      let(:command) { find_command('echo hello') }
-
-      it { expect{ command }.to raise_error Aruba::CommandNotFoundError }
-      it { expect{ command.commandline }.to raise_error Aruba::CommandNotFoundError }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Multiple commands
-    Given a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('echo hello1') }
-      before(:each) { run_command('echo hello2') }
-      let(:command) { find_command('echo hello1') }
-
-      before(:each) { stop_all_commands }
-
-      it { expect(command).to be_successfully_executed }
-      it { expect(command.commandline).to eq 'echo hello1' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Multiple commands with same commandline
-
-    If searches in reverse. So it finds the last command started with the given commandline.
-
-    Given a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { set_environment_variable 'ENV_VAR', '1' }
-      before(:each) { run_command('bash -c "echo -n $ENV_VAR"') }
-      before(:each) { set_environment_variable 'ENV_VAR', '2' }
-      before(:each) { run_command('bash -c "echo -n $ENV_VAR"') }
-
-      let(:command) { find_command('bash -c "echo -n $ENV_VAR"') }
-
-      before(:each) { stop_all_commands }
-
-      it { expect(command).to be_successfully_executed }
-      it { expect(command.stdout).to eq '2' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/04_aruba_api/command/find_command_in_PATH.feature

@@ -1,37 +0,0 @@
-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/aruba-test-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('aruba-test-cli')).to match %r{tmp/aruba/cli-app/bin/aruba-test-cli} }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Non-existing executable
-    Given a file named "bin/aruba-test-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('aruba-test-cli')).to be_nil }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/04_aruba_api/command/read_stderr_of_command.feature

@@ -1,46 +0,0 @@
-Feature: Access STDERR of command
-
-  You may need to `#stop_all_commands` before accessing `#stderr` of a single
-  command - e.g. `#last_command_started`.
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And the default aruba io wait timeout is 0.1 seconds
-
-  Scenario: Existing executable
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    echo 'Hello, Aruba!' >&2
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-      it { expect(last_command_started.stderr).to start_with  'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Waiting for output to appear
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    sleep 0.1
-    echo 'Hello, Aruba' >&2
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :io_wait_timeout => 0.2 do
-      before(:each) { run_command('aruba-test-cli') }
-      it { expect(last_command_started.stderr).to start_with 'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/04_aruba_api/command/read_stdout_of_command.feature

@@ -1,46 +0,0 @@
-Feature: Access STDOUT of command
-
-  You may need to `#stop_all_commands` before accessing `#stdout` of a single
-  command - e.g. `#last_command_started`.
-
-  Background:
-    Given I use a fixture named "cli-app"
-    And the default aruba io wait timeout is 1 seconds
-
-  Scenario: Existing executable
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    echo 'Hello, Aruba!'
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      before(:each) { stop_all_commands }
-      it { expect(last_command_started.stdout).to start_with  'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Waiting for output to appear
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    sleep 0.1
-    echo 'Hello, Aruba'
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :io_wait_timeout => 0.2 do
-      before(:each) { run_command('aruba-test-cli') }
-      it { expect(last_command_started.stdout).to start_with 'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/04_aruba_api/command/run_command.feature

@@ -1,423 +0,0 @@
-Feature: Run command
-
-  To run a command use the `#run_command` method. There are some configuration options
-  which are relevant here:
-
-  - `startup_wait_time`:
-
-    Given this option `aruba` waits n seconds after it started the command.
-    This is most useful when using `#run_command()` and not really makes sense for
-    `#run_command_and_stop()`.
-
-    You can use `#run_command()` + `startup_wait_time` to start background jobs.
-
-  - `exit_timeout`:
-
-    The exit timeout is used, when `aruba` waits for a command to finished.
-
-  - `io_wait_timeout`:
-
-    The io wait timeout is used, when you access `stdout` or `stderr` of a
-    command.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Existing executable
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Relative path to executable
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('bin/aruba-test-cli') }
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Non-existing executable
-    Given a file named "bin/aruba-test-cli" does not exist
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Find path for command', :type => :aruba do
-      it { expect { run_command('aruba-test-cli') }.to raise_error Aruba::LaunchError, /Command "aruba-test-cli" not found in PATH-variable/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Command with long startup phase
-
-    If you have got a command with a long startup phase or use `ruby` together
-    with `bundler`, you should consider using the `startup_wait_time`-option.
-    Otherwise methods like `#send_signal` don't work since they require the
-    command to be running and have setup it's signal handler.
-
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function initialize_script {
-      sleep 0.2
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    function recurring_work {
-      echo "Hello, Aruba here"
-    }
-
-    function stop_script {
-      exit 0
-    }
-
-    trap recurring_work HUP
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-
-    while [ true ]; do sleep 0.1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 0.1, :startup_wait_time => 0.2 do
-      before do
-        run_command('aruba-test-cli')
-        last_command_started.send_signal 'HUP'
-      end
-
-      it 'runs the command with the expected results' do
-        aggregate_failures do
-          expect(last_command_started).to be_successfully_executed
-          expect(last_command_started).to have_output /Hello, Aruba is working/
-          expect(last_command_started).to have_output /Hello, Aruba here/
-        end
-      end
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Long running command
-
-    If you have got a "long running" command, you should consider using the
-    `exit_timeout`-option.
-
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      sleep 0.2
-      echo "Hello, Aruba here"
-    }
-
-    do_some_work
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 0.3 do
-      before { run_command('aruba-test-cli') }
-
-      it 'runs the command with the expected results' do
-        aggregate_failures do
-          expect(last_command_started).to be_successfully_executed
-          expect(last_command_started).to have_output /Hello, Aruba here/
-        end
-      end
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Mixing commands with long and short startup phase (deprecated)
-
-    If you commands with a long and short startup phases, you should consider
-    using the `startup_wait_time`-option local to the `#run_command`-call.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/usr/bin/env bash
- 
-    function initialize_script {
-      sleep 2
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    function recurring_work {
-      echo "Hello, Aruba here"
-    }
-
-    function stop_script {
-      exit 0
-    }
-
-    trap recurring_work HUP
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-
-    while [ true ]; do sleep 0.2; done
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function initialize_script {
-      sleep 0
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    function recurring_work {
-      echo "Hello, Aruba here"
-    }
-
-    function stop_script {
-      exit 0
-    }
-
-    trap recurring_work HUP
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-
-    while [ true ]; do sleep 0.2; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 1 do
-      before(:each) { run_command('aruba-test-cli1', 3, 0.1, 'TERM', 2) }
-      before(:each) { run_command('aruba-test-cli2', 3, 0.1, 'TERM', 1) }
-      before(:each) { last_command_started.send_signal 'HUP' }
-
-      it { expect(last_command_started).to be_successfully_executed }
-      it { expect(last_command_started).to have_output /Hello, Aruba is working/ }
-      it { expect(last_command_started).to have_output /Hello, Aruba here/ }
-
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Mixing commands with long and short startup phase
-
-    If you commands with a long and short startup phases, you should consider
-    using the `startup_wait_time`-option local to the `#run_command`-call.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/usr/bin/env bash
- 
-    function initialize_script {
-      sleep 2
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    function recurring_work {
-      echo "Hello, Aruba here"
-    }
-
-    function stop_script {
-      exit 0
-    }
-
-    trap recurring_work HUP
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-
-    while [ true ]; do sleep 0.2; done
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function initialize_script {
-      sleep 0
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    function recurring_work {
-      echo "Hello, Aruba here"
-    }
-
-    function stop_script {
-      exit 0
-    }
-
-    trap recurring_work HUP
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-
-    while [ true ]; do sleep 0.2; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 1 do
-      before(:each) { run_command('aruba-test-cli1', :startup_wait_time => 2) }
-      before(:each) { run_command('aruba-test-cli2', :startup_wait_time => 1) }
-      before(:each) { last_command_started.send_signal 'HUP' }
-
-      it { expect(last_command_started).to be_successfully_executed }
-      it { expect(last_command_started).to have_output /Hello, Aruba is working/ }
-      it { expect(last_command_started).to have_output /Hello, Aruba here/ }
-
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Mixing long and short running commands (deprecated)
-
-    If need to mix "long running" and "short running" commands, you should consider using the
-    `exit_timeout`-option local to the `#run_command`-method.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      sleep 2
-      echo "Hello, Aruba here"
-    }
-
-    do_some_work
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      echo "Hello, Aruba here"
-    }
-
-    do_some_work
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli1', 3) }
-      before(:each) { run_command('aruba-test-cli2', 1) }
-
-      it { expect(last_command_started).to be_successfully_executed }
-      it { expect(last_command_started).to have_output /Hello, Aruba here/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Mixing long and short running commands
-
-    If need to mix "long running" and "short running" commands, you should consider using the
-    `exit_timeout`-option local to the `#run_command`-method.
-
-    Given an executable named "bin/aruba-test-cli1" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      sleep 2
-      echo "Hello, Aruba here"
-    }
-
-    do_some_work
-    """
-    And an executable named "bin/aruba-test-cli2" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      echo "Hello, Aruba here"
-    }
-
-    do_some_work
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli1', :exit_timeout => 3) }
-      before(:each) { run_command('aruba-test-cli2', :exit_timeout => 1) }
-
-      it { expect(last_command_started).to be_successfully_executed }
-      it { expect(last_command_started).to have_output /Hello, Aruba here/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Starting command twice fails
-    Given an executable named "bin/aruba-test-cli" with:
-    """bash
-    #!/bin/bash
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('aruba-test-cli') }
-      let!(:found_command) { find_command('aruba-test-cli') }
-      it { expect { found_command.start }.to raise_error Aruba::CommandAlreadyStartedError }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass