aruba 1.1.1 → 2.0.1

data/lib/aruba/cucumber/command.rb

@@ -32,108 +32,139 @@ When(/^I run `([^`]*)` in background$/) do |cmd|
   run_command(sanitize_text(cmd))
 end
 
-When(/^I type "([^"]*)"$/) do |input|
+When "I type {string}" do |input|
   type(unescape_text(input))
 end
 
-When(/^I close the stdin stream$/) do
+When "I close the stdin stream" do
   close_input
 end
 
-When(/^I pipe in (?:a|the) file(?: named)? "([^"]*)"$/) do |file|
+When "I pipe in a/the file( named) {string}" do |file|
   pipe_in_file(file)
 
   close_input
 end
 
-When(/^I (terminate|stop) the command (?:"([^"]*)"|(?:started last))$/) do |signal, command|
-  monitor = aruba.command_monitor
+When "I stop the command started last" do
+  last_command_started.stop
+end
 
-  cmd = if command
-          monitor.find(command)
-        else
-          last_command_started
-        end
+When "I stop the command {string}" do |command|
+  aruba.command_monitor.find(command).stop
+end
 
-  if signal == "terminate"
-    cmd.terminate
-  else
-    cmd.stop
-  end
+When "I terminate the command started last" do
+  last_command_started.terminate
+end
+
+When "I terminate the command {string}" do |command|
+  aruba.command_monitor.find(command).terminate
 end
 
 When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) \
   do |channel, expected|
-  begin
-    Timeout.timeout(aruba.config.exit_timeout) do
-      loop do
-        output = last_command_started.public_send channel.to_sym, wait_for_io: 0
 
-        output   = sanitize_text(output)
-        expected = sanitize_text(expected)
+  Timeout.timeout(aruba.config.exit_timeout) do
+    loop do
+      output = last_command_started.public_send channel.to_sym, wait_for_io: 0
 
-        if output.include? expected
-          last_command_started.terminate
+      output   = sanitize_text(output)
+      expected = sanitize_text(expected)
 
-          break
-        end
+      if output.include? expected
+        last_command_started.terminate
 
-        sleep 0.1
+        break
       end
+
+      sleep 0.1
     end
-  rescue ChildProcess::TimeoutError, Timeout::Error
-    last_command_started.terminate
   end
+rescue ChildProcess::TimeoutError, Timeout::Error
+  last_command_started.terminate
 end
 
-When(/^I wait for (?:output|stdout) to contain:$/) do |expected|
+When "I wait for output/stdout to contain:" do |expected|
   Timeout.timeout(aruba.config.exit_timeout) do
-    begin
-      expect(last_command_started).to have_output an_output_string_including(expected)
-    rescue ExpectationError
+    loop do
+      output = last_command_started.public_send :stdout, wait_for_io: 0
+
+      output   = sanitize_text(output)
+      expected = sanitize_text(expected)
+
+      break if output.include? expected
+
       sleep 0.1
-      retry
     end
   end
 end
 
-When(/^I wait for (?:output|stdout) to contain "([^"]*)"$/) do |expected|
+When "I wait for output/stdout to contain {string}" do |expected|
   Timeout.timeout(aruba.config.exit_timeout) do
-    begin
-      expect(last_command_started).to have_output an_output_string_including(expected)
-    rescue ExpectationError
+    loop do
+      output = last_command_started.public_send :stdout, wait_for_io: 0
+
+      output   = sanitize_text(output)
+      expected = sanitize_text(expected)
+
+      break if output.include? expected
+
       sleep 0.1
-      retry
     end
   end
 end
 
-Then(/^the output should be (\d+) bytes long$/) do |size|
+Then "the output should be {int} bytes long" do |size|
   expect(last_command_started.output).to have_output_size size.to_i
 end
 
 ## the stderr should contain "hello"
-Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)"$/) \
-  do |channel, negated, exactly, expected|
+Then "(the ){channel} should contain {string}" do |channel, expected|
   combined_output = send("all_#{channel}")
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  expect(combined_output).to include_output_string expected
+end
 
-  if negated
-    expect(combined_output).not_to send(output_string_matcher, expected)
-  else
-    expect(combined_output).to send(output_string_matcher, expected)
-  end
+## the stderr should not contain "hello"
+Then "(the ){channel} should not contain {string}" do |channel, expected|
+  combined_output = send("all_#{channel}")
+
+  expect(combined_output).not_to include_output_string expected
+end
+
+## the stderr should contain exactly "hello"
+Then "(the ){channel} should contain exactly {string}" do |channel, expected|
+  combined_output = send("all_#{channel}")
+
+  expect(combined_output).to output_string_eq expected
+end
+
+## the stderr should not contain exactly "hello"
+Then "(the ){channel} should not contain exactly {string}" do |channel, expected|
+  combined_output = send("all_#{channel}")
+
+  expect(combined_output).not_to output_string_eq expected
 end
 
 ## the stderr from "echo -n 'Hello'" should contain "hello"
-Then(
-  /^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)? "([^"]*)"$/
-) do |channel, cmd, exactly, expected|
+Then "(the ){channel} from {string} should contain {string}" do |channel, cmd, expected|
+  matcher = case channel
+            when "output"; then :have_output
+            when "stderr"; then :have_output_on_stderr
+            when "stdout"; then :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = :an_output_string_including
+
+  expect(command).to send(matcher, send(output_string_matcher, expected))
+end
+
+## the stderr from "echo -n 'Hello'" should contain exactly "hello"
+Then "(the ){channel} from {string} should contain exactly {string}" \
+  do |channel, cmd, expected|
   matcher = case channel
             when "output"; then :have_output
             when "stderr"; then :have_output_on_stderr
@@ -142,19 +173,13 @@ Then(
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  output_string_matcher = :an_output_string_being_eq
 
   expect(command).to send(matcher, send(output_string_matcher, expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain "hello"
-Then(
-  /^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)? "([^"]*)"$/
-) do |channel, cmd, exactly, expected|
+Then "(the ){channel} from {string} should not contain {string}" do |channel, cmd, expected|
   matcher = case channel
             when "output"; then :have_output
             when "stderr"; then :have_output_on_stderr
@@ -163,46 +188,72 @@ Then(
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  output_string_matcher = :an_output_string_including
 
   expect(command).not_to send(matcher, send(output_string_matcher, expected))
 end
 
-## the stderr should not contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) \
-  do |channel, exactly, expected|
+## the stderr from "echo -n 'Hello'" should not contain exactly "hello"
+Then "(the ){channel} from {string} should not contain exactly {string}" \
+  do |channel, cmd, expected|
+  matcher = case channel
+            when "output"; then :have_output
+            when "stderr"; then :have_output_on_stderr
+            when "stdout"; then :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = :an_output_string_being_eq
+
+  expect(command).not_to send(matcher, send(output_string_matcher, expected))
+end
+
+## the stderr should contain:
+Then "(the ){channel} should contain:" do |channel, expected|
   combined_output = send("all_#{channel}")
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  expect(combined_output).to include_output_string(expected)
+end
 
-  expect(combined_output).not_to send(output_string_matcher, expected)
+## the stderr should not contain:
+Then "(the ){channel} should not contain:" do |channel, expected|
+  combined_output = send("all_#{channel}")
+
+  expect(combined_output).not_to include_output_string(expected)
 end
 
 ## the stderr should contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) \
-  do |channel, exactly, expected|
+Then "(the ){channel} should contain exactly:" do |channel, expected|
   combined_output = send("all_#{channel}")
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  expect(combined_output).to output_string_eq(expected)
+end
+
+## the stderr should not contain exactly:
+Then "(the ){channel} should not contain exactly:" do |channel, expected|
+  combined_output = send("all_#{channel}")
 
-  expect(combined_output).to send(output_string_matcher, expected)
+  expect(combined_output).not_to output_string_eq(expected)
+end
+
+## the stderr from "echo -n 'Hello'" should not contain:
+Then "(the ){channel} from {string} should not contain:" do |channel, cmd, expected|
+  matcher = case channel
+            when "output"; then :have_output
+            when "stderr"; then :have_output_on_stderr
+            when "stdout"; then :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = :an_output_string_including
+
+  expect(command).not_to send(matcher, send(output_string_matcher, expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)?:$/) \
-  do |channel, cmd, exactly, expected|
+Then "(the ){channel} from {string} should not contain exactly:" do |channel, cmd, expected|
   matcher = case channel
             when "output"; then :have_output
             when "stderr"; then :have_output_on_stderr
@@ -211,18 +262,28 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactl
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  output_string_matcher = :an_output_string_being_eq
 
   expect(command).not_to send(matcher, send(output_string_matcher, expected))
 end
 
+## the stderr from "echo -n 'Hello'" should contain:
+Then "(the ){channel} from {string} should contain:" do |channel, cmd, expected|
+  matcher = case channel
+            when "output"; then :have_output
+            when "stderr"; then :have_output_on_stderr
+            when "stdout"; then :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = :an_output_string_including
+
+  expect(command).to send(matcher, send(output_string_matcher, expected))
+end
+
 ## the stderr from "echo -n 'Hello'" should contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)?:$/) \
-  do |channel, cmd, exactly, expected|
+Then "(the ){channel} from {string} should contain exactly:" do |channel, cmd, expected|
   matcher = case channel
             when "output"; then :have_output
             when "stderr"; then :have_output_on_stderr
@@ -231,11 +292,7 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)?:
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  output_string_matcher = :an_output_string_being_eq
 
   expect(command).to send(matcher, send(output_string_matcher, expected))
 end
@@ -247,35 +304,35 @@ end
 Then(%r{^the output should( not)? match /([^/]*)/$}) do |negated, expected|
   if negated
     expect(all_commands)
-      .not_to include_an_object have_output an_output_string_matching(expected)
+      .not_to include have_output an_output_string_matching(expected)
   else
     expect(all_commands)
-      .to include_an_object have_output an_output_string_matching(expected)
+      .to include have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the output should( not)? match %r<([^>]*)>$/) do |negated, expected|
   if negated
     expect(all_commands)
-      .not_to include_an_object have_output an_output_string_matching(expected)
+      .not_to include have_output an_output_string_matching(expected)
   else
     expect(all_commands)
-      .to include_an_object have_output an_output_string_matching(expected)
+      .to include have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the output should( not)? match:$/) do |negated, expected|
   if negated
     expect(all_commands)
-      .not_to include_an_object have_output an_output_string_matching(expected)
+      .not_to include have_output an_output_string_matching(expected)
   else
     expect(all_commands)
-      .to include_an_object have_output an_output_string_matching(expected)
+      .to include have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
-  last_command_started.stop if last_command_stopped.nil?
+  last_command_started.stop if last_command_stopped.empty?
 
   if negated
     expect(last_command_stopped).not_to have_exit_status exit_status.to_i
@@ -387,7 +444,7 @@ Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channe
             when "stdout"; then :have_output_on_stdout
             end
 
-  expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
+  expect(all_commands).to include send(matcher, be_nil.or(be_empty))
 end
 
 Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) \
@@ -403,10 +460,10 @@ Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:
 
     if negated
       expect(all_commands)
-        .not_to include_an_object have_output an_output_string_including(expected)
+        .not_to include have_output an_output_string_including(expected)
     else
       expect(all_commands)
-        .to include_an_object have_output an_output_string_including(expected)
+        .to include have_output an_output_string_including(expected)
     end
   end
 end
@@ -419,7 +476,7 @@ Given(/^the (?:default )?aruba exit timeout is ([\d.]+) seconds?$/) do |seconds|
   aruba.config.exit_timeout = seconds.to_f
 end
 
-Given(/^the (?:default )?aruba stop signal is "([^"]*)"$/) do |signal|
+Given "the( default) aruba stop signal is {string}" do |signal|
   aruba.config.stop_signal = signal
 end
 
@@ -427,18 +484,17 @@ Given(/^I wait ([\d.]+) seconds? for (?:a|the) command to start up$/) do |second
   aruba.config.startup_wait_time = seconds.to_f
 end
 
-When(/^I send the signal "([^"]*)" to the command (?:"([^"]*)"|(?:started last))$/) \
- do |signal, command|
-  if command
-    cmd = all_commands.find { |c| c.commandline == command }
-    raise ArgumentError, %(No command "#{command}" found) if cmd.nil?
+When "I send the signal {string} to the command {string}" do |signal, command|
+  cmd = all_commands.find { |c| c.commandline == command }
+  raise ArgumentError, %(No command "#{command}" found) if cmd.nil?
 
-    cmd.send_signal signal
-  else
-    last_command_started.send_signal signal
-  end
+  cmd.send_signal signal
+end
+
+When "I send the signal {string} to the command started last" do |signal|
+  last_command_started.send_signal signal
 end
 
-Given(/^I look for executables in "(.*)" within the current directory$/) do |directory|
+Given "I look for executables in {string} within the current directory" do |directory|
   prepend_environment_variable "PATH", expand_path(directory) + File::PATH_SEPARATOR
 end

data/lib/aruba/cucumber/file.rb

@@ -95,7 +95,7 @@ Then(/^the following files should (not )?exist:$/) do |negated, files|
   if negated
     expect(files).not_to include an_existing_file
   else
-    expect(files).to Aruba::Matchers.all be_an_existing_file
+    expect(files).to all be_an_existing_file
   end
 end
 
@@ -140,7 +140,7 @@ Then(/^the following directories should (not )?exist:$/) do |negated, directorie
   if negated
     expect(directories).not_to include an_existing_directory
   else
-    expect(directories).to Aruba::Matchers.all be_an_existing_directory
+    expect(directories).to all be_an_existing_directory
   end
 end
 

data/lib/aruba/cucumber/parameter_types.rb

@@ -0,0 +1 @@
+ParameterType(name: "channel", regexp: "output|stderr|stdout", transformer: ->(name) { name })

data/lib/aruba/cucumber.rb

@@ -2,6 +2,7 @@ require "aruba/version"
 
 require "aruba/api"
 require "aruba/cucumber/hooks"
+require "aruba/cucumber/parameter_types"
 require "aruba/cucumber/command"
 require "aruba/cucumber/environment"
 require "aruba/cucumber/file"

data/lib/aruba/event_bus/name_resolver.rb

@@ -150,7 +150,7 @@ module Aruba
       rescue StandardError => e
         types = @resolvers.map(&:supports).flatten.join(", ")
         message = "Transforming \"#{event_id}\" into an event class failed." \
-          " Supported types are: #{types}. #{e.message}."
+                  " Supported types are: #{types}. #{e.message}."
         raise EventNameResolveError, message, cause: e
       end
     end

data/lib/aruba/matchers/command/be_successfully_executed.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 require "aruba/matchers/command/have_exit_status"
 require "aruba/matchers/command/have_finished_in_time"
 

data/lib/aruba/matchers/command/have_exit_status.rb

@@ -18,33 +18,27 @@
 #     end
 RSpec::Matchers.define :have_exit_status do |expected|
   match do |actual|
-    @old_actual = actual
+    actual.stop
+    @actual_exit_status = actual.exit_status
 
-    @old_actual.stop
-    @actual = actual.exit_status
-
-    unless @old_actual.respond_to? :exit_status
-      raise "Expected #{@old_actual} to respond to #exit_status"
-    end
-
-    values_match? expected, @actual
+    values_match? expected, @actual_exit_status
   end
 
   failure_message do |actual|
     format(
       %(expected that command "%s" has exit status of "%s", but has "%s".),
-      @old_actual.commandline,
+      actual.commandline,
       expected.to_s,
-      actual.to_s
+      @actual_exit_status.to_s
     )
   end
 
   failure_message_when_negated do |actual|
     format(
       %(expected that command "%s" does not have exit status of "%s", but has "%s".),
-      @old_actual.commandline,
+      actual.commandline,
       expected.to_s,
-      actual.to_s
+      @actual_exit_status.to_s
     )
   end
 end

data/lib/aruba/matchers/command/have_finished_in_time.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method run_too_long
 #   This matchers checks if <command> run too long. Say the timeout is 10
 #   seconds and it takes <command> to finish in 15. This matchers will succeed.

data/lib/aruba/matchers/directory/be_an_existing_directory.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method be_an_existing_directory
 #   This matchers checks if <directory> exists in filesystem
 #

data/lib/aruba/matchers/directory/have_sub_directory.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method have_sub_directory(sub_directory)
 #   This matchers checks if <directory> has given sub-directory
 #

data/lib/aruba/matchers/file/be_a_command_found_in_path.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method be_a_command_found_in_path
 #   This matchers checks if <command> can be found in path
 #

data/lib/aruba/matchers/file/be_an_existing_executable.rb

@@ -1,4 +1,3 @@
-require "rspec/expectations/version"
 require "shellwords"
 
 # @!method be_an_existing_executable

data/lib/aruba/matchers/file/be_an_existing_file.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method be_an_existing_file
 #   This matchers checks if <file> exists in filesystem
 #

data/lib/aruba/matchers/file/have_file_content.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method have_file_content(content)
 #   This matchers checks if <file> has content. `content` can be a string,
 #   regexp or an RSpec matcher.

data/lib/aruba/matchers/file/have_file_size.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method have_file_size(size)
 #   This matchers checks if path has file size
 #

data/lib/aruba/matchers/file/have_same_file_content.rb

@@ -1,4 +1,3 @@
-require "rspec/expectations/version"
 require "fileutils"
 
 # @!method have_same_file_content_as(file_name)

data/lib/aruba/matchers/path/a_path_matching_pattern.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method a_path_matching_pattern(/pattern/)
 #   This matchers checks if <path> matches pattern. `pattern` can be a string,
 #   regexp or an RSpec matcher.

data/lib/aruba/matchers/path/be_an_absolute_path.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method be_an_absolute_path
 #   This matchers checks if <path> exists in filesystem
 #

data/lib/aruba/matchers/path/be_an_existing_path.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method be_an_existing_path
 #   This matchers checks if <path> exists in filesystem
 #

data/lib/aruba/matchers/path/have_permissions.rb

@@ -1,5 +1,3 @@
-require "rspec/expectations/version"
-
 # @!method have_permissions(permissions)
 #   This matchers checks if <file> or <directory> has <perm> permissions
 #

data/lib/aruba/platform.rb

@@ -5,10 +5,10 @@ require "aruba/platforms/windows_platform"
 module Aruba
   PLATFORM_MUTEX = Mutex.new
 
-  Platform = [Platforms::WindowsPlatform, Platforms::UnixPlatform].find(&:match?)
+  PLATFORM = [Platforms::WindowsPlatform, Platforms::UnixPlatform].find(&:match?)
 
   PLATFORM_MUTEX.synchronize do
-    @platform = Platform.new
+    @platform = PLATFORM.new
   end
 
   class << self

data/lib/aruba/platforms/announcer.rb

@@ -134,8 +134,6 @@ module Aruba
       #   The mode to set
       def mode=(m)
         @announcer = @announcers.find { |a| a.mode? m.to_sym }
-
-        self
       end
 
       # Fecth mode of announcer