aruba 0.6.2 → 0.7.0

data/lib/aruba/config.rb

@@ -37,7 +37,6 @@ module Aruba
     def configure
       yield config
     end
-
   end
 
   self.config = Config.new

data/lib/aruba/cucumber.rb

@@ -8,6 +8,11 @@ Given /the default aruba timeout is (\d+) seconds/ do |seconds|
   @aruba_timeout_seconds = seconds.to_i
 end
 
+Given /I use (?:a|the) fixture(?: named)? "([^"]*)"/ do |name|
+  copy File.join(Aruba::Api::FIXTURES_PATH_PREFIX, name), name
+  cd name
+end
+
 Given /The default aruba timeout is (\d+) seconds/ do |seconds|
   warn(%{\e[35m    The  /^The default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use the one with `the` and not `The` at the beginning.\e[0m})
   @aruba_timeout_seconds = seconds.to_i
@@ -17,37 +22,45 @@ Given /^I'm using a clean gemset "([^"]*)"$/ do |gemset|
   use_clean_gemset(gemset)
 end
 
-Given /^a directory named "([^"]*)"$/ do |dir_name|
+Given /^(?:a|the) directory(?: named)? "([^"]*)"$/ do |dir_name|
   create_dir(dir_name)
 end
 
-Given /^a directory named "([^"]*)" with mode "([^"]*)"$/ do |dir_name, dir_mode|
+Given /^(?:a|the) directory(?: named)? "([^"]*)" with mode "([^"]*)"$/ do |dir_name, dir_mode|
   create_dir(dir_name)
   filesystem_permissions(dir_mode, dir_name)
 end
 
-Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
+Given /^(?:a|the) file(?: named)? "([^"]*)" with:$/ do |file_name, file_content|
   write_file(file_name, file_content)
 end
 
-Given /^a file named "([^"]*)" with mode "([^"]*)" and with:$/ do |file_name, file_mode, file_content|
+Given /^(?:a|the) file(?: named)? "([^"]*)" with mode "([^"]*)" and with:$/ do |file_name, file_mode, file_content|
   write_file(file_name, file_content)
   filesystem_permissions(file_mode, file_name)
 end
 
-Given /^a (\d+) byte file named "([^"]*)"$/ do |file_size, file_name|
+Given /^(?:a|the) (\d+) byte file(?: named)? "([^"]*)"$/ do |file_size, file_name|
   write_fixed_size_file(file_name, file_size.to_i)
 end
 
-Given /^an empty file named "([^"]*)"$/ do |file_name|
+Given /^(?:an|the) empty file(?: named)? "([^"]*)"$/ do |file_name|
   write_file(file_name, "")
 end
 
-Given /^an empty file named "([^"]*)" with mode "([^"]*)"$/ do |file_name, file_mode|
+Given /^(?:an|the) empty file(?: named)? "([^"]*)" with mode "([^"]*)"$/ do |file_name, file_mode|
   write_file(file_name, "")
   filesystem_permissions(file_mode, file_name)
 end
 
+Given /^a mocked home directory$/ do
+  set_env 'HOME', File.expand_path(current_dir)
+end
+
+Given /^(?:a|the) directory(?: named)? "([^"]*)" does not exist$/ do |directory_name|
+  remove_directory(directory_name, force: true)
+end
+
 When /^I write to "([^"]*)" with:$/ do |file_name, file_content|
   write_file(file_name, file_content)
 end
@@ -64,12 +77,16 @@ When /^I append to "([^"]*)" with "([^"]*)"$/ do |file_name, file_content|
   append_to_file(file_name, file_content)
 end
 
-When /^I remove the file "([^"]*)"$/ do |file_name|
+When /^I remove (?:a|the) file(?: named)? "([^"]*)"$/ do |file_name|
   remove_file(file_name)
 end
 
-When(/^I remove the directory "(.*?)"$/) do |directory_name|
-  remove_dir(directory_name)
+Given /^(?:a|the) file(?: named)? "([^"]*)" does not exist$/ do |file_name|
+  remove_file(file_name, force: true)
+end
+
+When(/^I remove (?:a|the) directory(?: named)? "(.*?)"$/) do |directory_name|
+  remove_directory(directory_name)
 end
 
 When /^I cd to "([^"]*)"$/ do |dir|
@@ -85,6 +102,15 @@ Given /^I set the environment variables to:/ do |table|
   end
 end
 
+Given /^I append the value to the environment variable:/ do |table|
+  table.hashes.each do |row|
+    variable = row['variable'].to_s.upcase
+    value = row['value'].to_s + row['value'].to_s
+
+    set_env(variable, value)
+  end
+end
+
 When /^I run "(.*)"$/ do |cmd|
   warn(%{\e[35m    The /^I run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
   run_simple(unescape(cmd), false)
@@ -107,11 +133,11 @@ end
 
 When /^I run "([^"]*)" interactively$/ do |cmd|
   warn(%{\e[35m    The /^I run "([^"]*)" interactively$/ step definition is deprecated. Please use the `backticks` version\e[0m})
-  run_interactive(unescape(cmd))
+  step %(I run `#{cmd}` interactively)
 end
 
 When /^I run `([^`]*)` interactively$/ do |cmd|
-  run_interactive(unescape(cmd))
+  run(unescape(cmd))
 end
 
 When /^I type "([^"]*)"$/ do |input|
@@ -122,7 +148,7 @@ When /^I close the stdin stream$/ do
   close_input
 end
 
-When /^I pipe in the file "([^"]*)"$/ do |file|
+When /^I pipe in (?:a|the) file(?: named)? "([^"]*)"$/ do |file|
   pipe_in_file(file)
 
   close_input
@@ -292,82 +318,68 @@ Then /^the stderr from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, unexpec
   assert_no_partial_output(unexpected, stderr_from(cmd))
 end
 
-Then /^the file "([^"]*)" should not exist$/ do |file_name|
-  check_file_presence([file_name], false)
-end
-
-Then /^the following files should exist:$/ do |files|
-  check_file_presence(files.raw.map{|file_row| file_row[0]}, true)
-end
-
-Then /^the following files should not exist:$/ do |files|
-  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
-end
-
-Then /^a file named "([^"]*)" should exist$/ do |file|
-  check_file_presence([file], true)
-end
-
-Then /^a file named "([^"]*)" should not exist$/ do |file|
-  check_file_presence([file], false)
+Then /^the following files should (not )?exist:$/ do |expect_match, files|
+  files.raw.each do |row|
+    if expect_match
+      expect(row[0]).not_to be_existing_file
+    else
+      expect(row[0]).to be_existing_file
+    end
+  end
 end
 
-Then /^a file matching %r<(.*?)> should exist$/ do |regex|
-  check_file_presence([ Regexp.new( regex ) ], true )
+Then /^(?:a|the) file(?: named)? "([^"]*)" should (not )?exist$/ do |file, expect_match|
+  if expect_match
+    expect(file).not_to be_existing_file
+  else
+    expect(file).to be_existing_file
+  end
 end
 
-Then /^a file matching %r<(.*?)> should not exist$/ do |regex|
-  check_file_presence([ Regexp.new( regex ) ], false )
+Then /^(?:a|the) file matching %r<(.*?)> should (not )?exist$/ do |pattern, expect_match|
+  if expect_match
+    expect(all_paths).not_to match_path_pattern(Regexp.new(pattern))
+  else
+    expect(all_paths).to match_path_pattern(Regexp.new(pattern))
+  end
 end
 
-Then /^a (\d+) byte file named "([^"]*)" should exist$/ do |file_size, file_name|
+Then /^(?:a|the) (\d+) byte file(?: named)? "([^"]*)" should exist$/ do |file_size, file_name|
   check_file_size([[file_name, file_size.to_i]])
 end
 
-Then /^the following directories should exist:$/ do |directories|
-  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, true)
-end
-
-Then /^the following directories should not exist:$/ do |directories|
-  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, false)
+Then /^the following directories should (not )?exist:$/ do |expect_match, directories|
+  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, !expect_match)
 end
 
-Then /^a directory named "([^"]*)" should (not )?exist$/ do |directory, expect_match|
+Then /^(?:a|the) directory(?: named)? "([^"]*)" should (not )?exist$/ do |directory, expect_match|
   check_directory_presence([directory], !expect_match)
 end
 
-Then /^the file "([^"]*)" should (not )?contain "([^"]*)"$/ do |file, expect_match, partial_content|
+Then /^(?:a|the) file "([^"]*)" should (not )?contain "([^"]*)"$/ do |file, expect_match, partial_content|
   check_file_content(file, Regexp.compile(Regexp.escape(partial_content)), !expect_match)
 end
 
-Then /^the file "([^"]*)" should (not )?contain:$/ do |file, expect_match, partial_content|
+Then /^(?:a|the) file "([^"]*)" should (not )?contain:$/ do |file, expect_match, partial_content|
   check_file_content(file, Regexp.compile(Regexp.escape(partial_content)), !expect_match)
 end
 
-Then /^the file "([^"]*)" should (not )?contain exactly:$/ do |file, expect_match, exact_content|
+Then /^(?:a|the) file "([^"]*)" should (not )?contain exactly:$/ do |file, expect_match, exact_content|
   check_file_content(file, exact_content, !expect_match)
 end
 
-Then /^the file "([^"]*)" should (not )?match \/([^\/]*)\/$/ do |file, expect_match, partial_content|
+Then /^(?:a|the) file "([^"]*)" should (not )?match \/([^\/]*)\/$/ do |file, expect_match, partial_content|
   check_file_content(file, /#{partial_content}/, !expect_match)
 end
 
-Then /^the file "([^"]*)" should (not )?be equal to file "([^"]*)"/ do |file, expect_match, reference_file|
+Then /^(?:a|the) file "([^"]*)" should (not )?be equal to file "([^"]*)"/ do |file, expect_match, reference_file|
   check_binary_file_content(file, reference_file, !expect_match)
 end
 
-Then /^the mode of filesystem object "([^"]*)" should match "([^"]*)"$/ do |file, mode|
-  check_filesystem_permissions(mode, file, true)
-end
-
-Given /^a mocked home directory$/ do
-  set_env 'HOME', File.expand_path(current_dir)
+Then /^the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)"$/ do |file, expect_match, mode|
+  check_filesystem_permissions(mode, file, !expect_match)
 end
 
 Before '@mocked_home_directory' do
-  set_env 'HOME', File.expand_path(current_dir)
-end
-
-After do
-  restore_env
+  set_env 'HOME', expand_path('.')
 end

data/lib/aruba/cucumber/hooks.rb

@@ -12,39 +12,44 @@ After do
 end
 
 Before('~@no-clobber') do
-  clean_current_dir
+  clean_current_directory
 end
 
 Before('@puts') do
-  @puts = true
+  announcer.mode = :puts
 end
 
 Before('@announce-cmd') do
-  @announce_cmd = true
+  announcer.activate :command
 end
 
 Before('@announce-stdout') do
-  @announce_stdout = true
+  announcer.activate :stdout
 end
 
 Before('@announce-stderr') do
-  @announce_stderr = true
+  announcer.activate :stderr
 end
 
 Before('@announce-dir') do
-  @announce_dir = true
+  announcer.activate :directory
 end
 
 Before('@announce-env') do
-  @announce_env = true
+  announcer.activate :environment
 end
 
 Before('@announce') do
-  @announce_stdout = true
-  @announce_stderr = true
-  @announce_cmd = true
-  @announce_dir = true
-  @announce_env = true
+  announcer.activate :command
+  announcer.activate :stdout
+  announcer.activate :stderr
+  announcer.activate :directory
+  announcer.activate :environment
+end
+
+Before('@debug') do
+  require 'aruba/processes/debug_process'
+  Aruba.process = Aruba::Processes::DebugProcess
 end
 
 Before('@ansi') do
@@ -53,5 +58,5 @@ end
 
 After do
   restore_env
-  processes.clear
+  process_monitor.clear
 end

data/lib/aruba/errors.rb

@@ -1,4 +1,10 @@
 module Aruba
+  # Standard error
   class Error < StandardError; end
+
+  # An error because a user of the API did something wrong
+  class UserError < StandardError; end
+
+  # Raised on launch error
   class LaunchError < Error; end
 end

data/lib/aruba/in_process.rb

@@ -1,51 +1,11 @@
-require 'shellwords'
-require 'stringio'
+require 'aruba/processes/in_process'
 
 module Aruba
-  class InProcess
-    include Shellwords
+  class InProcess < Aruba::Processes::InProcess
+    def initialize(*args)
+      warn('The use of "Aruba::InProcess" is deprecated. Use "Aruba::Processes::InProcess" instead.')
 
-    class FakeKernel
-      attr_reader :exitstatus
-
-      def initialize
-        @exitstatus = 0
-      end
-
-      def exit(exitstatus)
-        @exitstatus = exitstatus
-      end
-    end
-
-    def self.main_class=(main_class)
-      @@main_class = main_class
-    end
-
-    def initialize(cmd, exit_timeout, io_wait)
-      args = shellwords(cmd)
-      @argv = args[1..-1]
-      @stdin = StringIO.new
-      @stdout = StringIO.new
-      @stderr = StringIO.new
-      @kernel = FakeKernel.new
-    end
-
-    def run!
-      raise "You need to call Aruba::InProcess.main_class = YourMainClass" unless @@main_class
-      @@main_class.new(@argv, @stdin, @stdout, @stderr, @kernel).execute!
-      yield self if block_given?
-    end
-
-    def stop(reader)
-      @kernel.exitstatus
-    end
-
-    def stdout
-      @stdout.string
-    end
-
-    def stderr
-      @stderr.string
+      super
     end
   end
 end

data/lib/aruba/matchers/command.rb

@@ -0,0 +1,79 @@
+# @!method have_exit_status(status)
+#   This matchers checks if <command> has exit status <status>
+#
+#   @param [Integer] status
+#     The value of the exit status
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command does not have exit status
+#     true:
+#     * if command has exit status
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command).to have_exit_status(0) }
+#     end
+RSpec::Matchers.define :have_exit_status do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    @announcer ||= Aruba::Announcer.new(
+      self,
+      :stdout => @announce_stdout,
+      :stderr => @announce_stderr,
+      :dir    => @announce_dir,
+      :cmd    => @announce_cmd,
+      :env    => @announce_env
+    )
+
+    @old_actual.stop(@announcer) unless @old_actual.stopped?
+    @actual = actual.exit_status
+
+    next false unless @old_actual.respond_to? :exit_status
+
+    values_match? expected, @actual
+  end
+
+  failure_message do |actual|
+    format(%(expected that command "%s" has exit status of "%s", but has "%s".), @old_actual.commandline, expected.to_s, actual.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, expected.to_s, actual.to_s)
+  end
+end
+
+# @!method be_successfuly_executed
+#   This matchers checks if execution of <command> was successful
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command was not successful
+#     true:
+#     * if command was successful
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command).to be_successfully_executed }
+#     end
+RSpec::Matchers.define :be_successfully_executed do
+  match do |actual|
+    @old_actual = actual
+    @actual = actual.exit_status
+
+    expect(@old_actual).to have_exit_status 0
+  end
+
+  failure_message do |actual|
+    format(%(expected that command "%s" has exit status of "%s", but has "%s".), @old_actual.commandline, '0', actual.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, '0', actual.to_s)
+  end
+end