aruba 0.11.0.pre → 0.11.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0d970f3502a082de16bb266924f0c7900377b76
-  data.tar.gz: 011f90e024a29624795ad9883d29b8547c3fdeda
+  metadata.gz: 5e93dadabb88f5dd615ae393d84932f5f1c2eb6b
+  data.tar.gz: d08af1d7ff5dcc684d05fcd03a9795caa476d244
 SHA512:
-  metadata.gz: e769fd6414236a83911ef5e5c3a068ea88f8795d2de079ae140b834b452fc0a89167ff2e7466fed1a88c920105cd884652d791d5d246d20361da5fbe763f3faa
-  data.tar.gz: e2415039514fa5fa15ebf0649e13aaafaf339f77348c5a1167b792f08ea7c7c31ba37eb9af6cf1dae1f54cdb40634d90cc8a0dbc97479fd84a43b668a2e5f0ec
+  metadata.gz: 800cedf76eaaadb53e801974ccf9df8d9d6ba8534aaa0591606d3aa28e8f6ba6c92d802e8549c43862b0f387795a655472475b34254646350980ec2159a369d4
+  data.tar.gz: 0af17d2ae845c40a06b0be27433868d8f2637c22774566a67353a8c5e4a66e8079d53b6cad7ef9d80a3115a8486bbf4a600a71ea497ef8fb130709b10c133022

data/Gemfile

@@ -42,7 +42,7 @@ group :development, :test do
   gem 'simplecov', '~> 0.10'
 
   # Test api
-  gem 'rspec', '~> 3.3.0'
+  gem 'rspec', '~> 3.4'
   gem 'fuubar', '~> 2.0.0'
 
   # using platform for this make bundler complain about the same gem given

data/History.md

@@ -14,12 +14,14 @@
 * Added announce formatter for time spans, e.g. `startup_wait_time`
 * All `*Process`-classes e.g. `BasicProcess`, `SpawnProcess` etc. are marked as
   private. Users should use `#run('cmd')` and don't use the classes directly.
+* `rvm`-methods are deprecated. They too ruby specific.
+
+# Old releases
 
 ## [v0.10.2](https://github.com/cucumber/aruba/compare/v0.10.1...v0.10.2)
 
 * Fixed problem in regex after merge of step definitions
 
-# Old releases
 
 ## [v0.10.1](https://github.com/cucumber/aruba/compare/v0.10.0...v0.10.1)
 
@@ -445,6 +447,24 @@
 
 # Upcoming un-released versions
 
+## [v0.11.0.pre2](https://github.com/cucumber/aruba/compare/v0.11.pre2...v0.11.0.pre2)
+
+* Integrate `EventBus` to decouple announcers from starting, stopping commands
+  etc. This uses nearly the same implementation like `cucumber`. (PR #309)
+* Starting/Stopping a command directly (`command.start`, `command.stop`) is now
+  reported to the command monitor and `last_command_stopped` is updated
+  correctly
+* Added `#restart` to `Command` to make it possible to restart a command
+* Added check to prevent a command which has already been started, to be
+  started again. Otherwise you've got hidden commands which are not stopped
+  after a cucumber/rspec/minitest run.
+* Adding alot of documentation to `aruba`
+* Refactored `#run`: Now it wants you to pass a `Hash` containing the options.
+  The old syntax is still supported, but is deprecated.
+* Added `#find_command` as experimental feature. It searches the started
+  commands from last to first.
+* Added `be_an_executable` matcher
+
 ## [v1.0.0](https://github.com/cucumber/aruba/compare/v0.11.0...v1.0.0)
 
 * Support for rubies older than 1.9.3 is discontinued - e.g 1.8.7 and 1.9.2

data/aruba.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rspec-expectations', '>= 2.99'
   s.add_runtime_dependency 'contracts', '~> 0.9'
   s.add_runtime_dependency 'thor', '~> 0.19'
+  s.add_runtime_dependency 'event-bus', '~> 0.2.0'
 
   s.add_development_dependency 'bundler', '~> 1.10.2'
 

data/features/api/command/find_command.feature

@@ -0,0 +1,83 @@
+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: Exising command
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('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-Exising 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('echo hello1') }
+      before(:each) { run('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('bash -c "echo -n $ENV_VAR"') }
+      before(:each) { set_environment_variable 'ENV_VAR', '2' }
+      before(:each) { run('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/api/command/last_command_started.feature

@@ -0,0 +1,50 @@
+Feature: Return last command started
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: A command has been started
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('echo hello') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started).to be_successfully_executed }
+      it { expect(last_command_started.commandline).to eq 'echo hello' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Multiple commands have been started
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('echo hello') }
+      before(:each) { run('echo world') }
+
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_started).to be_successfully_executed }
+      it { expect(last_command_started.commandline).to eq 'echo world' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: No command has been started
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      it { expect{ last_command_started.commandline }.to raise_error Aruba::NoCommandHasBeenStartedError }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/command/last_command_stopped.feature

@@ -0,0 +1,89 @@
+Feature: Return last command stopped
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: A command has been started
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('echo hello') }
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_stopped).to be_successfully_executed }
+      it { expect(last_command_stopped.commandline).to eq 'echo hello' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Multiple commands have been started and all are stopped
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('echo hello') }
+      before(:each) { run('echo world') }
+
+      before(:each) { stop_all_commands }
+
+      it { expect(last_command_stopped).to be_successfully_executed }
+      it { expect(last_command_stopped.commandline).to eq 'echo world' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Multiple commands have been started and a single one is stopped
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      before(:each) { run('echo hello') }
+      before(:each) { find_command('echo hello').stop }
+      before(:each) { run('echo world') }
+
+      it { expect(last_command_stopped).to be_successfully_executed }
+      it { expect(last_command_stopped.commandline).to eq 'echo hello' }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+
+  @requires-aruba-version-1
+  Scenario: No command has been started
+    Given a file named "spec/run_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe 'Run command', :type => :aruba do
+      it { expect{ last_command_stopped.commandline }.to raise_error Aruba::NoCommandHasBeenStoppedError }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  @requires-aruba-version-1
+  Scenario: No command has been stopped
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/bin/bash
+    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') }
+
+      it { expect{ last_command_stopped.commandline }.to raise_error Aruba::NoCommandHasBeenStoppedError }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/api/command/run.feature

@@ -153,3 +153,262 @@ Feature: Run command
     """
     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`-call.
+
+    Given an executable named "bin/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/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('cli1', 3, 0.1, 'TERM', 2) }
+      before(:each) { run('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`-call.
+
+    Given an executable named "bin/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/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('cli1', :startup_wait_time => 2) }
+      before(:each) { run('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`-method.
+
+    Given an executable named "bin/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/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('cli1', 3) }
+      before(:each) { run('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`-method.
+
+    Given an executable named "bin/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/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('cli1', :exit_timeout => 3) }
+      before(:each) { run('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/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('cli') }
+      let!(:found_command) { find_command('cli') }
+      it { expect { found_command.start }.to raise_error Aruba::CommandAlreadyStartedError }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass