aruba 0.11.0.pre → 0.11.0.pre2

data/features/api/command/stop.feature

@@ -3,11 +3,63 @@ Feature: Stop command
   To stop commands via API you can do the following:
 
   - `last_command_started.stop`
-  - `stop_all_commands`
+  - `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

data/features/api/text/replace_variables.feature

@@ -37,7 +37,7 @@ Feature: Replace variables
     require 'spec_helper'
 
     RSpec.describe 'Run command', :type => :aruba do
-      it { expect(replace_variables('<pid-last-command-started>')).to eq '0' }
+      it { expect { replace_variables('<pid-last-command-started>') }.to raise_error Aruba::NoCommandHasBeenStartedError }
     end
     """
     When I run `rspec`

data/features/getting_started/run_commands.feature

@@ -0,0 +1,177 @@
+Feature: Run commands with Aruba
+
+  As long as you've got the neccessary programs, libraries, runtime
+  environments, interpreters installed, it doesn't matter in which programming
+  language your commandline application is implemented. You can even use POSIX
+  standard tools like "printf".
+
+  Below you find some examples of the "Hello, Aruba!"-application implemented
+  with different programming languages and a single example for a POSIX
+  standard tool. This is NOT an exclusive list. Every commandline application
+  should run with `aruba`.
+
+  Background:
+    Given I use a fixture named "getting-started-app"
+    And a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given I successfully run `cli`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+
+  Scenario: Bash Program
+    Given an executable named "bin/cli" with:
+    """bash
+    #!/usr/bin/env bash
+
+    echo "Hello, Aruba!"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Bash Program run via bash
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.sh" with:
+        \"\"\"
+        echo "Hello, Aruba!"
+        \"\"\"
+        When I successfully run `bash ./cli.sh`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Ruby Program
+    Given an executable named "bin/cli" with:
+    """ruby
+    #!/usr/bin/env ruby
+
+    puts "Hello, Aruba!"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Ruby Program via "ruby"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.rb" with:
+        \"\"\"
+        puts "Hello, Aruba!"
+        \"\"\"
+        When I successfully run `ruby ./cli.rb`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Python Program
+    Given an executable named "bin/cli" with:
+    """python
+    #!/usr/bin/env python
+
+    print("Hello, Aruba!")
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Python Program via "python"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.py" with:
+        \"\"\"
+        print("Hello, Aruba!")
+        \"\"\"
+        When I successfully run `python ./cli.py`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Perl Program
+    Given an executable named "bin/cli" with:
+    """perl
+    #!/usr/bin/env perl
+
+    print "Hello, Aruba!\n";
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Perl Program via "perl"
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "cli.pl" with:
+        \"\"\"perl
+        print "Hello, Aruba!\n";
+        \"\"\"
+        When I successfully run `perl ./cli.pl`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: Java Program
+
+    It's even possible to compile and run Java programs with Aruba.
+
+    Given a file named "features/hello_aruba.feature" with:
+    """cucumber
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given a file named "tmp/HelloArubaApp.java" with:
+        \"\"\"
+        class HelloArubaApp {
+          public static void main(String[] args) {
+            System.out.println("Hello, Aruba!");
+          }
+        }
+        \"\"\"
+        And I successfully run `javac tmp/HelloArubaApp.java`
+        And I cd to "tmp/"
+        And I successfully run `java HelloArubaApp`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass
+
+  Scenario: POSIX standard tools
+    Given a file named "features/hello_aruba.feature" with:
+    """
+    Feature: Getting Started With Aruba
+      Scenario: First Run of Command
+        Given I successfully run `printf "%s" "Hello, Aruba!"`
+        Then the output should contain:
+        \"\"\"
+        Hello, Aruba!
+        \"\"\"
+    """
+    When I successfully run `cucumber`
+    Then the features should all pass

data/features/matchers/file/be_existing_executable.feature

@@ -0,0 +1,87 @@
+Feature: Check if path exists and is an executable file
+
+  If you need to check if a given path exists and is a file, you can use the
+  `be_an_existing_executable`-matcher.
+
+  ```ruby
+  require 'spec_helper'
+
+  RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+    let(:file) { 'file.txt' }
+    before(:each) { touch(file) }
+
+    it { expect(file).to be_an_existing_executable }
+  end
+  ```
+
+  Background:
+    Given I use a fixture named "cli-app"
+
+  Scenario: Expect single existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      before(:each) { touch(file) }
+      before(:each) { chmod(0755, file) }
+
+      it { expect(file).to be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect single non-existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:file) { 'file.txt' }
+      it { expect(file).not_to be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect multiple existing executable files
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        files.each do |f|
+          touch(f)
+          chmod(0755, f)
+        end
+      end
+
+      it { expect(files).to all be_an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass
+
+  Scenario: Expect a least one existing executable file
+    Given a file named "spec/existing_executable_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Check if file exists and is an executable file', :type => :aruba do
+      let(:files) { %w(file1.txt file2.txt) }
+
+      before :each do
+        touch(files.first)
+        chmod(0755, files.first)
+      end
+
+      it { expect(files).to include an_existing_executable }
+    end
+    """
+    When I run `rspec`
+    Then the specs should all pass

data/features/{integration/rspec/getting_started.feature → rspec/integration.feature}

@@ -117,6 +117,35 @@ Feature: Getting started with RSpec and aruba
     When I run `rspec`
     Then the specs should all pass
 
+  Scenario: Setup aruba before use any of it's methods
+
+    From 1.0.0 it will be required, that you setup aruba before you use it.
+
+    Given a file named "spec/spec_helper.rb" with:
+    """
+    require 'aruba/api'
+
+    RSpec.configure do |config|
+      config.include Aruba::Api
+    end
+    """
+    And a file named "spec/getting_started_spec.rb" with:
+    """
+    require 'spec_helper'
+
+    RSpec.describe 'Custom Integration of aruba' do
+      let(:file) { 'file.txt' }
+
+      before(:each) { setup_aruba }
+
+      it { expect(true).to be true }
+    end
+    """
+    And an empty file named "tmp/aruba/garbage.txt"
+    When I run `rspec`
+    Then the specs should all pass
+    And the file "tmp/aruba/garbage.txt" should not exist anymore
+
   Scenario: Fail-safe use if "setup_aruba" is not used
 
     If you forgot to run `setup_aruba` before the first method of aruba is
@@ -125,6 +154,8 @@ Feature: Getting started with RSpec and aruba
     Make sure that you run `setup_aruba` before any method of aruba is used. At
     best before each and every test.
 
+    This will be not supported anymore from 1.0.0 on.
+
     Given a file named "spec/spec_helper.rb" with:
     """
     require 'aruba/api'

data/fixtures/getting-started-app/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 gem 'cucumber'
-gem 'aruba'
+gem 'aruba', path: File.expand_path('../../../../', __FILE__)

data/lib/aruba.rb

@@ -1,20 +1 @@
-# require 'contracts'
-
-# require 'fileutils'
-# require 'rbconfig'
-# require 'ostruct'
-# require 'pathname'
-
-# require 'aruba/hooks'
-# require 'aruba/basic_configuration'
-# require 'aruba/config_wrapper'
-# require 'aruba/config'
-
-# require 'aruba/announcer'
-# require 'aruba/process_monitor'
-# require 'aruba/runtime'
-
-# require 'aruba/platform'
-# require 'aruba/spawn_process'
-
 require 'aruba/api'

data/lib/aruba/api.rb

@@ -19,7 +19,9 @@ require 'aruba/api/rvm'
 
 Aruba.platform.require_matching_files('../matchers/**/*.rb', __FILE__)
 
+# Aruba
 module Aruba
+  # Api
   module Api
     include Aruba::Api::Core
     include Aruba::Api::Commands

data/lib/aruba/api/command.rb

@@ -1,11 +1,11 @@
 require 'pathname'
 
 require 'aruba/platform'
-require 'aruba/process_monitor'
 require 'aruba/command'
 
 # require 'win32/file' if File::ALT_SEPARATOR
 
+# Aruba
 module Aruba
   class << self
     # @deprecated
@@ -16,8 +16,11 @@ module Aruba
   # self.process = Aruba::Processes::SpawnProcess
 end
 
+# Aruba
 module Aruba
+  # Api
   module Api
+    # Command module
     module Commands
       # Resolve path for command using the PATH-environment variable
       #
@@ -53,31 +56,17 @@ module Aruba
       # @return [Array]
       #   List of commands
       def all_commands
-        process_monitor.all_commands
-      end
-
-      # @private
-      def process_monitor
-        return @process_monitor if defined? @process_monitor
-
-        @process_monitor = ProcessMonitor.new(announcer)
-
-        @process_monitor
-      end
-
-      # @private
-      def processes
-        process_monitor.send(:processes)
+        aruba.command_monitor.registered_commands
       end
 
       # Last command started
       def last_command_started
-        process_monitor.last_command_started
+        aruba.command_monitor.last_command_started
       end
 
       # Last command stopped
       def last_command_stopped
-        process_monitor.last_command_stopped
+        aruba.command_monitor.last_command_stopped
       end
 
       # Stop all commands
@@ -92,7 +81,7 @@ module Aruba
                  all_commands
                end
 
-        cmds.each { |c| c.stop(announcer) }
+        cmds.each(&:stop)
 
         self
       end
@@ -114,27 +103,61 @@ module Aruba
         self
       end
 
+      # Find a started command
+      #
+      # @param [String, Command] commandline
+      #   The commandline
+      def find_command(commandline)
+        aruba.command_monitor.find(commandline)
+      end
+
       # Run given command and stop it if timeout is reached
       #
       # @param [String] cmd
       #   The command which should be executed
       #
-      # @param [Integer] timeout
+      # @param [Hash] opts
+      #   Options
+      #
+      # @option [Integer] exit_timeout
       #   If the timeout is reached the command will be killed
       #
-      # @param [String] stop_signal
-      #   Use signal to stop command (Private)
+      # @option [Integer] io_wait_timeout
+      #   Wait for IO to finish
+      #
+      # @option [Integer] startup_wait_time
+      #   Wait for a command to start
+      #
+      # @option [String] stop_signal
+      #   Use signal to stop command
       #
       # @yield [SpawnProcess]
       #   Run block with process
       #
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/CyclomaticComplexity
-      def run(cmd, exit_timeout = nil, io_wait_timeout = nil, stop_signal = nil, startup_wait_time = nil)
-        exit_timeout ||= aruba.config.exit_timeout
-        io_wait_timeout ||= aruba.config.io_wait_timeout
-        stop_signal ||= aruba.config.stop_signal
-        startup_wait_time ||= aruba.config.startup_wait_time
+      def run(*args)
+        fail ArgumentError, 'Please pass at least a command as first argument.' if args.size < 1
+
+        cmd = args.shift
+
+        if args.last.is_a? Hash
+          opts = args.pop
+
+          exit_timeout      = opts.fetch(:exit_timeout, aruba.config.exit_timeout)
+          io_wait_timeout   = opts.fetch(:io_wait_timeout, aruba.config.io_wait_timeout)
+          stop_signal       = opts.fetch(:stop_signal, aruba.config.stop_signal)
+          startup_wait_time = opts.fetch(:startup_wait_time, aruba.config.startup_wait_time)
+        else
+          if args.size > 1
+            Aruba.platform.deprecated("Please pass options to `#run` as named parameters/hash and don\'t use the old style, e.g. `#run('cmd', :exit_timeout => 5)`.")
+          end
+
+          exit_timeout      = args[0] || aruba.config.exit_timeout
+          io_wait_timeout   = args[1] || aruba.config.io_wait_timeout
+          stop_signal       = args[2] || aruba.config.stop_signal
+          startup_wait_time = args[3] || aruba.config.startup_wait_time
+        end
 
         cmd = replace_variables(cmd)
 
@@ -143,16 +166,17 @@ module Aruba
 
         environment       = aruba.environment.to_h
         working_directory = expand_path('.')
+        event_bus         = aruba.event_bus
 
-        announcer.announce(:full_environment, environment)
-        announcer.announce(:timeout, 'exit', exit_timeout)
-        announcer.announce(:timeout, 'io wait', io_wait_timeout)
-        announcer.announce(:wait_time, 'startup wait time', startup_wait_time)
+        aruba.announcer.announce(:full_environment, environment)
+        aruba.announcer.announce(:timeout, 'exit', exit_timeout)
+        aruba.announcer.announce(:timeout, 'io wait', io_wait_timeout)
+        aruba.announcer.announce(:wait_time, 'startup wait time', startup_wait_time)
 
-        announcer.announce(:directory, working_directory)
-        announcer.announce(:command, cmd)
+        aruba.announcer.announce(:directory, working_directory)
+        aruba.announcer.announce(:command, cmd)
 
-        cmd               = Aruba.platform.detect_ruby(cmd)
+        cmd = Aruba.platform.detect_ruby(cmd)
 
         mode = if Aruba.process
                  # rubocop:disable Metrics/LineLength
@@ -181,7 +205,8 @@ module Aruba
           :environment       => environment,
           :main_class        => main_class,
           :stop_signal       => stop_signal,
-          :startup_wait_time => startup_wait_time
+          :startup_wait_time => startup_wait_time,
+          :event_bus         => event_bus
         )
 
         if aruba.config.before? :cmd
@@ -192,11 +217,9 @@ module Aruba
         end
 
         aruba.config.before(:command, self, command)
-
-        process_monitor.register_process(cmd, command)
         command.start
 
-        announcer.announce(:stop_signal, command.pid, stop_signal) if stop_signal
+        aruba.announcer.announce(:stop_signal, command.pid, stop_signal) if stop_signal
 
         aruba.config.after(:command, self, command)
 
@@ -213,22 +236,58 @@ module Aruba
       # @param [String] cmd
       #   The command to be executed
       #
-      # @param [TrueClass,FalseClass] fail_on_error
+      # @param [Hash] options
+      #   Options for aruba
+      #
+      # @option [TrueClass,FalseClass] fail_on_error
       #   Should aruba fail on error?
       #
-      # @param [Integer] timeout
+      # @option [Integer] exit_timeout
       #   Timeout for execution
-      def run_simple(cmd, fail_on_error = true, exit_timeout = nil, io_wait_timeout = nil)
-        command = run(cmd, exit_timeout, io_wait_timeout)
-        @last_exit_status = process_monitor.stop_process(command)
+      #
+      # @option [Integer] io_wait_timeout
+      #   Timeout for IO - STDERR, STDOUT
+      #
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
+      def run_simple(*args)
+        fail ArgumentError, 'Please pass at least a command as first argument.' if args.size < 1
+
+        cmd = args.shift
+
+        if args.last.is_a? Hash
+          opts = args.pop
+
+          fail_on_error   = opts.fetch(:fail_on_error, false) || false
+          exit_timeout    = opts.fetch(:exit_timeout, aruba.config.exit_timeout) || aruba.config.exit_timeout
+          io_wait_timeout = opts.fetch(:io_wait_timeout, aruba.config.io_wait_timeout) || aruba.config.io_wait_timeout
+        else
+          if args.size > 1
+            # rubocop:disable Metrics/LineLength
+            Aruba.platform.deprecated("Please pass options to `#run_simple` as named parameters/hash and don\'t use the old style with positional parameters, NEW: e.g. `#run_simple('cmd', :exit_timeout => 5)`.")
+            # rubocop:enable Metrics/LineLength
+          end
+
+          fail_on_error     = args[0] || true
+          exit_timeout      = args[1] || aruba.config.exit_timeout
+          io_wait_timeout   = args[2] || aruba.config.io_wait_timeout
+        end
+
+        command = run(cmd, :exit_timeout => exit_timeout, :io_wait_timeout => io_wait_timeout)
+        command.stop
 
-        @timed_out = command.timed_out?
+        if Aruba::VERSION < '1'
+          @last_exit_status = command.exit_status
+          @timed_out = command.timed_out?
+        end
 
         if fail_on_error
           expect(command).to have_finished_in_time
           expect(command).to be_successfully_executed
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
 
       # Provide data to command via stdin
       #