aruba 0.14.10 → 1.0.0

data/lib/aruba/cucumber/command.rb

@@ -1,38 +1,33 @@
-if Aruba::VERSION < '1.0.0'
-  require 'aruba/cucumber/core'
-end
 require 'aruba/generators/script_file'
 
-When(/^I run `([^`]*)`$/)do |cmd|
+When(/^I run `([^`]*)`$/) do |cmd|
   cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd, :fail_on_error => false)
+  run_command_and_stop(cmd, fail_on_error: false)
 end
 
 ## I successfully run `echo -n "Hello"`
 ## I successfully run `sleep 29` for up to 30 seconds
 When(/^I successfully run `(.*?)`(?: for up to ([\d.]+) seconds)?$/) do |cmd, secs|
   cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd, :fail_on_error => true, :exit_timeout => secs && secs.to_f)
+  run_command_and_stop(cmd, fail_on_error: true, exit_timeout: secs && secs.to_f)
 end
 
 When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) do |shell, commands|
-  prepend_environment_variable('PATH', expand_path('bin') + File::PATH_SEPARATOR)
+  full_path = expand_path('bin/myscript')
 
   Aruba.platform.mkdir(expand_path('bin'))
   shell ||= Aruba.platform.default_shell
 
-  Aruba::ScriptFile.new(:interpreter => shell, :content => commands,
-                        :path => expand_path('bin/myscript')).call
-  step 'I run `myscript`'
+  Aruba::ScriptFile.new(interpreter: shell, content: commands, path: full_path).call
+  run_command_and_stop(Shellwords.escape(full_path), fail_on_error: false)
 end
 
-When(/^I run `([^`]*)` interactively$/)do |cmd|
-  cmd = sanitize_text(cmd)
-  @interactive = run_command(cmd)
+When(/^I run `([^`]*)` interactively$/) do |cmd|
+  run_command(sanitize_text(cmd))
 end
 
 # Merge interactive and background after refactoring with event queue
-When(/^I run `([^`]*)` in background$/)do |cmd|
+When(/^I run `([^`]*)` in background$/) do |cmd|
   run_command(sanitize_text(cmd))
 end
 
@@ -51,39 +46,26 @@ When(/^I pipe in (?:a|the) file(?: named)? "([^"]*)"$/) do |file|
 end
 
 When(/^I (terminate|stop) the command (?:"([^"]*)"|(?:started last))$/) do |signal, command|
-  if command
-    cmd = all_commands.find { |c| c.commandline == command }
-    fail ArgumentError, %(No command "#{command}" found) if cmd.nil?
+  monitor = aruba.command_monitor
 
-    if signal == 'terminate'
-      # last_command_started.terminate
-      process_monitor.terminate_process!(process_monitor.get_process(command))
-    else
-      # last_command_started.stop
-      process_monitor.stop_process(process_monitor.get_process(command))
-    end
+  cmd = if command
+          monitor.find(command)
+        else
+          last_command_started
+        end
+
+  if signal == 'terminate'
+    cmd.terminate
   else
-    if signal == 'terminate'
-      # last_command_started.terminate
-      process_monitor.terminate_process!(last_command_started)
-    else
-      # last_command_started.stop
-      process_monitor.stop_process(last_command_started)
-    end
+    cmd.stop
   end
 end
 
 When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) do |channel, expected|
-  fail %(Invalid output channel "#{channel}" chosen. Please choose one of "output, stdout or stderr") unless %w(output stdout stderr).include? channel
-
   begin
     Timeout.timeout(aruba.config.exit_timeout) do
       loop do
-        output = if RUBY_VERSION < '1.9.3'
-                   last_command_started.send channel.to_sym, :wait_for_io => 0
-                 else
-                   last_command_started.public_send channel.to_sym, :wait_for_io => 0
-                 end
+        output = last_command_started.public_send channel.to_sym, wait_for_io: 0
 
         output   = sanitize_text(output)
         expected = sanitize_text(expected)
@@ -97,7 +79,7 @@ When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$
         sleep 0.1
       end
     end
-  rescue ChildProcess::TimeoutError, TimeoutError
+  rescue ChildProcess::TimeoutError, Timeout::Error
     last_command_started.terminate
   end
 end
@@ -136,15 +118,9 @@ Then(/^the output should be (\d+) 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|
-  combined_output = case channel.to_sym
-                    when :output
-                      all_output
-                    when :stderr
-                      all_stderr
-                    when :stdout
-                      all_stdout
-                    end
+  combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -159,6 +135,7 @@ Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)
   end
 end
 
+## the stderr from "echo -n 'Hello'" should contain "hello"
 Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
   matcher = case channel.to_sym
             when :output
@@ -184,15 +161,9 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exa
   end
 end
 
-Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)?:$/) do |channel, negated, exactly, expected|
-  combined_output = case channel.to_sym
-                    when :output
-                      all_output
-                    when :stderr
-                      all_stderr
-                    when :stdout
-                      all_stdout
-                    end
+## the stderr should not contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) do |channel, exactly, expected|
+  combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -200,14 +171,24 @@ Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)?:$/) do |
                             :an_output_string_including
                           end
 
-  if negated
-    expect(combined_output).not_to send(output_string_matcher, expected)
-  else
-    expect(combined_output).to send(output_string_matcher, expected)
-  end
+  expect(combined_output).not_to send(output_string_matcher, expected)
+end
+
+## the stderr should contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) do |channel, exactly, 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 send(output_string_matcher, expected)
 end
 
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exactly)?:$/) do |channel, cmd, negated, exactly, expected|
+## 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|
   matcher = case channel.to_sym
             when :output
               :have_output
@@ -225,11 +206,29 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exa
                             :an_output_string_including
                           end
 
-  if negated
-    expect(command).not_to send(matcher, send(output_string_matcher, expected))
-  else
-    expect(command).to send(matcher, send(output_string_matcher, expected))
-  end
+  expect(command).not_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|
+  matcher = case channel.to_sym
+            when :output
+              :have_output
+            when :stderr
+              :have_output_on_stderr
+            when :stdout
+              :have_output_on_stdout
+            end
+
+  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
+
+  expect(command).to send(matcher, send(output_string_matcher, expected))
 end
 
 # "the output should match" allows regex in the partial_output, if
@@ -261,6 +260,10 @@ Then(/^the output should( not)? match:$/) do |negated, expected|
 end
 
 Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
+  if last_command_stopped.nil?
+    last_command_started.stop
+  end
+
   if negated
     expect(last_command_stopped).not_to have_exit_status exit_status.to_i
   else
@@ -268,60 +271,100 @@ Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
   end
 end
 
-Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with:$/) do |pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with exactly:$/) do |pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+end
+
+Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
 end
 
-Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+end
+
+Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_matching(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_matching(expected)
 end
 
 Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channel|
@@ -332,8 +375,6 @@ Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channe
               :have_output_on_stderr
             when :stdout
               :have_output_on_stdout
-            else
-              fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
             end
 
   expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
@@ -341,16 +382,16 @@ end
 
 Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) do |channel, negated, table|
   table.raw.flatten.each do |expected|
-    matcher = case channel.to_sym
-              when :output
-                :have_output
-              when :stderr
-                :have_output_on_stderr
-              when :stdout
-                :have_output_on_stdout
-              else
-                fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
-              end
+    case channel.to_sym
+    when :output
+      :have_output
+    when :stderr
+      :have_output_on_stderr
+    when :stdout
+      :have_output_on_stdout
+    end
+
+    # TODO: This isn't actually using the above. It's hardcoded to use have_output only
 
     if negated
       expect(all_commands).not_to include_an_object have_output an_output_string_including(expected)

data/lib/aruba/cucumber/environment.rb

@@ -1,4 +1,4 @@
-Given(/^a mocked home directory$/)do
+Given(/^a mocked home directory$/) do
   set_environment_variable 'HOME', expand_path('.')
 end
 

data/lib/aruba/cucumber/file.rb

@@ -3,11 +3,11 @@ Given(/^I use (?:a|the) fixture(?: named)? "([^"]*)"$/) do |name|
   cd name
 end
 
-Given(/^I copy (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+Given(/^I copy (?:a|the) (?:file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |source, destination|
   copy source, destination
 end
 
-Given(/^I move (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+Given(/^I move (?:a|the) (?:file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |source, destination|
   move source, destination
 end
 
@@ -42,11 +42,11 @@ Given(/^(?:a|the) (\d+) byte file(?: named)? "([^"]*)"$/) do |file_size, file_na
 end
 
 Given(/^(?:an|the) empty file(?: named)? "([^"]*)"$/) do |file_name|
-  write_file(file_name, "")
+  write_file(file_name, '')
 end
 
 Given(/^(?:an|the) empty file(?: named)? "([^"]*)" with mode "([^"]*)"$/) do |file_name, file_mode|
-  write_file(file_name, "")
+  write_file(file_name, '')
   chmod(file_mode, file_name)
 end
 
@@ -67,11 +67,11 @@ When(/^I append to "([^"]*)" with "([^"]*)"$/) do |file_name, file_content|
 end
 
 When(/^I remove (?:a|the) (?:file|directory)(?: named)? "([^"]*)"( with full force)?$/) do |name, force_remove|
-  remove(name, :force => force_remove.nil? ? false : true)
+  remove(name, force: force_remove.nil? ? false : true)
 end
 
 Given(/^(?:a|the) (?:file|directory)(?: named)? "([^"]*)" does not exist$/) do |name|
-  remove(name, :force => true)
+  remove(name, force: true)
 end
 
 When(/^I cd to "([^"]*)"$/) do |dir|
@@ -79,7 +79,7 @@ When(/^I cd to "([^"]*)"$/) do |dir|
 end
 
 Then(/^the following files should (not )?exist:$/) do |negated, files|
-  files = files.rows.flatten
+  files = files.raw.flatten
 
   if negated
     expect(files).not_to include an_existing_file
@@ -88,21 +88,19 @@ Then(/^the following files should (not )?exist:$/) do |negated, files|
   end
 end
 
-Then(/^(?:a|the) (file|directory)(?: named)? "([^"]*)" should (not )?exist(?: anymore)?$/) do |directory_or_file, path, expect_match|
-  if directory_or_file == 'file'
-    if expect_match
-      expect(path).not_to be_an_existing_file
-    else
-      expect(path).to be_an_existing_file
-    end
-  elsif directory_or_file == 'directory'
-    if expect_match
-      expect(path).not_to be_an_existing_directory
-    else
-      expect(path).to be_an_existing_directory
-    end
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?exist(?: anymore)?$/) do |path, expect_match|
+  if expect_match
+    expect(path).not_to be_an_existing_file
+  else
+    expect(path).to be_an_existing_file
+  end
+end
+
+Then(/^(?:a|the) directory(?: named)? "([^"]*)" should (not )?exist(?: anymore)?$/) do |path, expect_match|
+  if expect_match
+    expect(path).not_to be_an_existing_directory
   else
-    fail ArgumentError, %("#{directory_or_file}" can only be "directory" or "file".)
+    expect(path).to be_an_existing_directory
   end
 end
 
@@ -156,7 +154,7 @@ Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain exactly:$/) do
   end
 end
 
-Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match %r<([^\/]*)>$/) do |file, negated, content|
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match %r<([^>]*)>$/) do |file, negated, content|
   if negated
     expect(file).not_to have_file_content file_content_matching(content)
   else
@@ -180,7 +178,7 @@ Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?be equal to file "([^"]
   end
 end
 
-Then(/^the (?:file|directory)(?: named)? "([^"]*)" should( not)? have permissions "([^"]*)"$/) do |path, negated, permissions|
+Then(/^(?:a|the) (?:file|directory)(?: named)? "([^"]*)" should( not)? have permissions "([^"]*)"$/) do |path, negated, permissions|
   if negated
     expect(path).not_to have_permissions(permissions)
   else

data/lib/aruba/cucumber/hooks.rb

@@ -3,10 +3,8 @@ require 'aruba/api'
 require 'aruba/platform'
 World(Aruba::Api)
 
-if Aruba::VERSION >= '1.0.0'
-  Around do |_, block|
-    Aruba.platform.with_environment(&block)
-  end
+Around do |_, block|
+  with_environment(&block)
 end
 
 Before do
@@ -97,17 +95,8 @@ Before('@announce') do
   aruba.announcer.activate :command_filesystem_status
 end
 
-Before('@debug') do
-  aruba.config.command_launcher = :debug
-end
-
-# After('@debug') do
-#   aruba.config.command_launcher = :spawn
-# end
-
 Before('@keep-ansi-escape-sequences') do
   aruba.config.remove_ansi_escape_sequences = false
-  aruba.config.keep_ansi = true
 end
 
 Before '@mocked-home-directory' do
@@ -117,3 +106,19 @@ end
 Before('@disable-bundler') do
   unset_bundler_env_vars
 end
+
+Before('@debug') do
+  aruba.config.command_launcher = :debug
+end
+
+Before('@command-launcher-spawn') do
+  aruba.config.command_launcher = :spawn
+end
+
+Before('@command-launcher-in-process') do
+  aruba.config.command_launcher = :in_process
+end
+
+Before('@command-launcher-debug') do
+  aruba.config.command_launcher = :debug
+end