aruba 0.14.9 → 1.0.0

data/features/api/command/run_simple.feature

@@ -1,242 +0,0 @@
-Feature: Run command
-
-  To run a command use the `#run_command_and_stop`-method. There are some configuration options
-  which are relevant here:
-
-  - `fail_on_error`:
-
-    Given this option is `true`, `aruba` fails if the `command` fails to run - exit code <> 0.
-
-    For all other options see [run.feature](run.feature).
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Require executable to succeed (by default value)
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli') }.to raise_error RSpec::Expectations::ExpectationNotMetError }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Require executable to succeed (set by option)
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli', :fail_on_error => true) }.to raise_error }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Require executable to succeed (set by option, deprecated)
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli', true) }.to raise_error }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Ignore failure of executable (set by option)
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli', :fail_on_error => false) }.not_to raise_error }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Ignore failure of executable (set by option, deprecated)
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli', false) }.not_to raise_error }
-    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/cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function initialize_script {
-      sleep 2
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    initialize_script
-    do_some_work
-
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 1, :startup_wait_time => 2 do
-      before(:each) { run_command_and_stop('cli') }
-
-      it { expect(last_command_started).to be_successfully_executed }
-      it { expect(last_command_started).to have_output /Hello, Aruba is working/ }
-    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/cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function do_some_work {
-      sleep 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 => 3 do
-      before(:each) { run_command_and_stop('cli') }
-
-      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: Sending signals to commands started with `#run_command_and_stop()`
-
-    Sending signals to a command which is started by
-    `#run_command_and_stop()` does not make sense. The command is stopped internally when
-    its exit status is checked.
-
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/usr/bin/env bash
-
-    function initialize_script {
-      sleep 1
-    }
-
-    function cleanup_script {
-      sleep 1
-    }
-
-    function do_some_work {
-      echo "Hello, Aruba is working"
-    }
-
-    trap stop_script TERM
-
-    initialize_script
-    do_some_work
-    cleanup_script
-    exit 0
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 2, :startup_wait_time => 1 do
-      before(:each) { run_command_and_stop('cli') }
-      it { expect { last_command_started.send_signal 'HUP' }.to raise_error Aruba::CommandAlreadyStoppedError }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Activate announcer channels on failure
-
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    echo "Hello, I'm STDOUT"
-    echo "Hello, I'm STDERR" 1>&2
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    Aruba.configure do |config|
-      config.activate_announcer_on_command_failure = [:stdout, :stderr]
-    end
-
-    RSpec.describe 'Run command', :type => :aruba do
-      it { expect { run_command_and_stop('cli', :fail_on_error => true) }.to_not raise_error }
-    end
-    """
-    When I run `rspec`
-    Then the specs should not pass
-    And the output should contain:
-    """
-    <<-STDOUT
-    Hello, I'm STDOUT
-
-    STDOUT
-    <<-STDERR
-    Hello, I'm STDERR
-
-    STDERR
-    """

data/features/api/command/send_signal.feature

@@ -1,53 +0,0 @@
-Feature: Send running command a signal
-
-  You can send a running command a signal using
-  `last_command_started#send_signal`. This is only supported with
-  `aruba.config.command_launcher = :spawn` (default).
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Existing executable
-    Given an executable named "bin/cli" with:
-    """ruby
-    #!/usr/bin/env bash
-
-    function hup {
-      echo 'Exit...' >&2
-      exit 0
-    }
-
-    trap hup HUP
-
-    while [ true ]; do sleep 1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 1, :startup_wait_time => 5 do
-      before(:each) { run_command('cli') }
-      before(:each) { last_command_started.send_signal 'HUP' }
-      it { expect(last_command_started).to have_output /Exit/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Dying command
-    Given an executable named "bin/cli" with:
-    """ruby
-    #!/usr/bin/env bash
-    exit 1
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba, :exit_timeout => 1, :startup_wait_time => 5 do
-      before(:each) { run_command('cli') }
-      it { expect { last_command_started.send_signal 'HUP' }.to raise_error Aruba::CommandAlreadyStoppedError, /Command "cli" with PID/ }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/api/command/stderr.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 1 seconds
-
-  Scenario: Existing executable
-    Given an executable named "bin/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('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" after 2 seconds
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    sleep 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 => 2 do
-      before(:each) { run_command('cli') }
-      it { expect(last_command_started.stderr).to start_with 'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/api/command/stdout.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/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('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" after 2 seconds
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    sleep 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 => 2 do
-      before(:each) { run_command('cli') }
-      it { expect(last_command_started.stdout).to start_with 'Hello' }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/api/command/stop.feature

@@ -1,131 +0,0 @@
-Feature: Stop command
-
-  To stop commands via API you can do the following:
-
-  - `last_command_started.stop`
-  - `find_command('command').stop`
-
-  But normally there's no need to stop a command manually. All matchers
-  handling commands make sure, that they stop ALL command before check actual
-  against expected.
-
-  Background:
-    Given I use a fixture named "cli-app"
-
-  Scenario: Stop command started last
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    function term {
-      exit 0
-    }
-
-    trap term TERM
-    while [ true ]; do sleep 1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('cli') }
-      before(:each) { last_command_started.stop }
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Find and stop command
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    function term {
-      exit 0
-    }
-
-    trap term TERM
-    while [ true ]; do sleep 1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('cli') }
-      before(:each) { find_command('cli').stop }
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Stop successful command with configured signal
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    function hup {
-      echo "Exit..."
-      exit 0
-    }
-
-    function term {
-      echo "No! No exit here. Try HUP. I stop the command with exit 1."
-      exit 1
-    }
-
-    trap hup HUP
-    trap term TERM
-    while [ true ]; do sleep 1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    Aruba.configure do |config|
-      config.stop_signal  = 'HUP'
-      config.exit_timeout = 1
-    end
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('cli') }
-      it { expect(last_command_started).to be_successfully_executed }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass
-
-  Scenario: Stop unsuccessful command with configured signal
-    Given an executable named "bin/cli" with:
-    """bash
-    #!/bin/bash
-    function hup {
-      echo "Exit..."
-      exit 2
-    }
-
-    function term {
-      echo "No! No exit here. Try HUP. I stop the command with exit 1."
-      exit 1
-    }
-
-    trap hup HUP
-    trap term TERM
-    while [ true ]; do sleep 1; done
-    """
-    And a file named "spec/run_spec.rb" with:
-    """ruby
-    require 'spec_helper'
-
-    Aruba.configure do |config|
-      config.stop_signal  = 'HUP'
-      config.exit_timeout = 1
-    end
-
-    RSpec.describe 'Run command', :type => :aruba do
-      before(:each) { run_command('cli') }
-      it { expect(last_command_started).to have_exit_status 2 }
-    end
-    """
-    When I run `rspec`
-    Then the specs should all pass

data/features/api/command/stop_all_commands.feature

@@ -1,53 +0,0 @@
-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_command('cli') }
-      before(:each) { run_command('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_command('cli') }
-      before(:each) { @cmd2 = run_command('cli') }
-      before(:each) { @cmd3 = run_command('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

@@ -1,53 +0,0 @@
-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_command('cli') }
-      before(:each) { run_command('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_command('cli') }
-      before(:each) { @cmd2 = run_command('cli') }
-      before(:each) { @cmd3 = run_command('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

@@ -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/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