aruba-win-fix 0.14.2

data/features/api/command/run_simple.feature

@@ -0,0 +1,242 @@
+Feature: Run command
+
+  To run a command use the `#run`-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_simple('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_simple('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_simple('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_simple('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_simple('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_simple('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_simple('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_simple()`
+
+    Sending signals to a command which is started by
+    `#run_simple()` 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_simple('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_simple('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

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

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

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

@@ -0,0 +1,131 @@
+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('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('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('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('cli') }
+      it { expect(last_command_started).to have_exit_status 2 }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass