aruba 2.1.0 → 2.3.0

data/lib/aruba/cucumber/command.rb

@@ -1,64 +1,77 @@
-require "aruba/generators/script_file"
+# frozen_string_literal: true
 
-When(/^I run `([^`]*)`$/) do |cmd|
+require 'aruba/generators/script_file'
+
+When 'I run {command}' do |cmd|
   cmd = sanitize_text(cmd)
   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|
+When 'I successfully run {command}' do |cmd|
+  cmd = sanitize_text(cmd)
+  run_command_and_stop(cmd, fail_on_error: true)
+end
+
+When 'I successfully run {command} for up to {float} 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.to_f)
+end
+
+When 'I run the following commands:/script:' do |commands|
+  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: full_path).call
+  run_command_and_stop(Shellwords.escape(full_path), fail_on_error: false)
 end
 
-When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) \
-  do |shell, commands|
-  full_path = expand_path("bin/myscript")
+When 'I run the following commands/script with/in {command}:' do |shell, commands|
+  full_path = expand_path('bin/myscript')
 
-  Aruba.platform.mkdir(expand_path("bin"))
-  shell ||= Aruba.platform.default_shell
+  Aruba.platform.mkdir(expand_path('bin'))
 
   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|
+When 'I run {command} 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 {command} in background' do |cmd|
   run_command(sanitize_text(cmd))
 end
 
-When "I type {string}" 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) {string}" do |file|
+When 'I pipe in a/the file( named) {string}' do |file|
   pipe_in_file(file)
 
   close_input
 end
 
-When "I stop the command started last" do
+When 'I stop the command started last' do
   last_command_started.stop
 end
 
-When "I stop the command {string}" do |command|
+When 'I stop the command {string}' do |command|
   aruba.command_monitor.find(command).stop
 end
 
-When "I terminate the command started last" do
+When 'I terminate the command started last' do
   last_command_started.terminate
 end
 
-When "I terminate the command {string}" do |command|
+When 'I terminate the command {string}' do |command|
   aruba.command_monitor.find(command).terminate
 end
 
@@ -81,14 +94,14 @@ When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$
       sleep 0.1
     end
   end
-rescue ChildProcess::TimeoutError, Timeout::Error
+rescue 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
     loop do
-      output = last_command_started.public_send :stdout, wait_for_io: 0
+      output = last_command_started.stdout wait_for_io: 0
 
       output   = sanitize_text(output)
       expected = sanitize_text(expected)
@@ -100,10 +113,10 @@ When "I wait for output/stdout to contain:" do |expected|
   end
 end
 
-When "I wait for output/stdout to contain {string}" do |expected|
+When 'I wait for output/stdout to contain {string}' do |expected|
   Timeout.timeout(aruba.config.exit_timeout) do
     loop do
-      output = last_command_started.public_send :stdout, wait_for_io: 0
+      output = last_command_started.stdout wait_for_io: 0
 
       output   = sanitize_text(output)
       expected = sanitize_text(expected)
@@ -115,44 +128,44 @@ When "I wait for output/stdout to contain {string}" do |expected|
   end
 end
 
-Then "the output should be {int} bytes long" do |size|
-  expect(last_command_started.output).to have_output_size size.to_i
+Then 'the output should be {int} bytes long' do |size|
+  expect(last_command_started).to have_output_size size.to_i
 end
 
 ## the stderr should contain "hello"
-Then "(the ){channel} should contain {string}" do |channel, expected|
-  combined_output = send("all_#{channel}")
+Then '(the ){channel} should contain {string}' do |channel, expected|
+  combined_output = send(:"all_#{channel}")
 
   expect(combined_output).to include_output_string expected
 end
 
 ## the stderr should not contain "hello"
-Then "(the ){channel} should not contain {string}" do |channel, expected|
-  combined_output = send("all_#{channel}")
+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}")
+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}")
+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 ){channel} from {string} should contain {string}" do |channel, cmd, 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
+            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))
@@ -163,12 +176,12 @@ Then "(the ){channel} from {string} should contain {string}" do |channel, cmd, e
 end
 
 ## the stderr from "echo -n 'Hello'" should contain exactly "hello"
-Then "(the ){channel} from {string} should contain exactly {string}" \
+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
-            when "stdout"; then :have_output_on_stdout
+            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))
@@ -179,11 +192,11 @@ Then "(the ){channel} from {string} should contain exactly {string}" \
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain "hello"
-Then "(the ){channel} from {string} should not contain {string}" do |channel, cmd, 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
-            when "stdout"; then :have_output_on_stdout
+            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))
@@ -194,12 +207,12 @@ Then "(the ){channel} from {string} should not contain {string}" do |channel, cm
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly "hello"
-Then "(the ){channel} from {string} should not contain exactly {string}" \
+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
+            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))
@@ -210,39 +223,39 @@ Then "(the ){channel} from {string} should not contain exactly {string}" \
 end
 
 ## the stderr should contain:
-Then "(the ){channel} should contain:" do |channel, expected|
-  combined_output = send("all_#{channel}")
+Then '(the ){channel} should contain:' do |channel, expected|
+  combined_output = send(:"all_#{channel}")
 
   expect(combined_output).to include_output_string(expected)
 end
 
 ## the stderr should not contain:
-Then "(the ){channel} should not contain:" do |channel, expected|
-  combined_output = send("all_#{channel}")
+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 ){channel} should contain exactly:" do |channel, expected|
-  combined_output = send("all_#{channel}")
+Then '(the ){channel} should contain exactly:' do |channel, expected|
+  combined_output = send(:"all_#{channel}")
 
   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}")
+Then '(the ){channel} should not contain exactly:' 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 not contain:
-Then "(the ){channel} from {string} should not contain:" do |channel, cmd, expected|
+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
+            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))
@@ -253,11 +266,11 @@ Then "(the ){channel} from {string} should not contain:" do |channel, cmd, expec
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly:
-Then "(the ){channel} from {string} should not contain exactly:" do |channel, cmd, 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
-            when "stdout"; then :have_output_on_stdout
+            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))
@@ -268,11 +281,11 @@ Then "(the ){channel} from {string} should not contain exactly:" do |channel, cm
 end
 
 ## the stderr from "echo -n 'Hello'" should contain:
-Then "(the ){channel} from {string} should contain:" do |channel, cmd, expected|
+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
+            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))
@@ -283,11 +296,11 @@ Then "(the ){channel} from {string} should contain:" do |channel, cmd, expected|
 end
 
 ## the stderr from "echo -n 'Hello'" should contain exactly:
-Then "(the ){channel} from {string} should contain exactly:" do |channel, cmd, 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
-            when "stdout"; then :have_output_on_stdout
+            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))
@@ -344,7 +357,7 @@ end
 Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -356,7 +369,7 @@ end
 Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -368,7 +381,7 @@ end
 Then(/^it should not (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -380,7 +393,7 @@ end
 Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -392,7 +405,7 @@ end
 Then(/^it should not (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -404,19 +417,19 @@ end
 Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
+  expect(last_command_stopped.output).to output_string_eq(expected)
 end
 
 Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -428,7 +441,7 @@ end
 Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == "pass"
+  if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -437,23 +450,19 @@ Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expect
   expect(last_command_stopped).to have_output an_output_string_matching(expected)
 end
 
-Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channel|
-  matcher = case channel
-            when "output"; then :have_output
-            when "stderr"; then :have_output_on_stderr
-            when "stdout"; then :have_output_on_stdout
-            end
+Then '(the ){channel} should not contain anything' do |channel|
+  combined_output = send(:"all_#{channel}")
 
-  expect(all_commands).to include send(matcher, be_nil.or(be_empty))
+  expect(combined_output).to output_string_eq ''
 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
-               when "output"; then :have_output
-               when "stderr"; then :have_output_on_stderr
-               when "stdout"; then :have_output_on_stdout
+               when 'output'; then :have_output
+               when 'stderr'; then :have_output_on_stderr
+               when 'stdout'; then :have_output_on_stdout
                end
 
     # TODO: This isn't actually using the above. It's hardcoded to use have_output only
@@ -476,7 +485,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 {string}" do |signal|
+Given 'the( default) aruba stop signal is {string}' do |signal|
   aruba.config.stop_signal = signal
 end
 
@@ -484,17 +493,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 {string} to the command {string}" do |signal, command|
+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
 end
 
-When "I send the signal {string} to the command started last" do |signal|
+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 {string} within the current directory" do |directory|
-  prepend_environment_variable "PATH", expand_path(directory) + File::PATH_SEPARATOR
+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/environment.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 Given(/^a mocked home directory$/) do
-  set_environment_variable "HOME", expand_path(".")
+  set_environment_variable 'HOME', expand_path('.')
 end
 
 Given(/^I set the environment variable "(.*)" to "(.*)"/) do |variable, value|
@@ -16,8 +18,8 @@ end
 
 Given(/^I set the environment variables? to:/) do |table|
   table.hashes.each do |row|
-    variable = row["variable"].to_s
-    value = row["value"].to_s
+    variable = row['variable'].to_s
+    value = row['value'].to_s
 
     set_environment_variable(variable, value)
   end
@@ -25,8 +27,8 @@ end
 
 Given(/^I append the values? to the environment variables?:/) do |table|
   table.hashes.each do |row|
-    variable = row["variable"].to_s
-    value = row["value"].to_s
+    variable = row['variable'].to_s
+    value = row['value'].to_s
 
     append_environment_variable(variable, value)
   end
@@ -34,8 +36,8 @@ end
 
 Given(/^I prepend the values? to the environment variables?:/) do |table|
   table.hashes.each do |row|
-    variable = row["variable"].to_s
-    value = row["value"].to_s
+    variable = row['variable'].to_s
+    value = row['value'].to_s
 
     prepend_environment_variable(variable, value)
   end

data/lib/aruba/cucumber/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Given(/^I use (?:a|the) fixture(?: named)? "([^"]*)"$/) do |name|
   copy File.join(aruba.config.fixtures_path_prefix, name), name
   cd name
@@ -46,12 +48,12 @@ 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