aruba 1.0.4 → 2.0.0

data/lib/aruba/contracts/absolute_path.rb

@@ -1,4 +1,4 @@
-require 'aruba/platform'
+require "aruba/platform"
 
 # Aruba
 module Aruba

data/lib/aruba/contracts/enum.rb

@@ -1,4 +1,4 @@
-require 'contracts'
+require "contracts"
 
 # Aruba
 module Aruba

data/lib/aruba/contracts/is_power_of_two.rb

@@ -1,4 +1,4 @@
-require 'aruba/aruba_path'
+require "aruba/aruba_path"
 
 # Aruba
 module Aruba

data/lib/aruba/contracts/relative_path.rb

@@ -1,4 +1,4 @@
-require 'aruba/platform'
+require "aruba/platform"
 
 # Aruba
 module Aruba

data/lib/aruba/cucumber.rb

@@ -1,8 +1,9 @@
-require 'aruba/version'
+require "aruba/version"
 
-require 'aruba/api'
-require 'aruba/cucumber/hooks'
-require 'aruba/cucumber/command'
-require 'aruba/cucumber/environment'
-require 'aruba/cucumber/file'
-require 'aruba/cucumber/testing_frameworks'
+require "aruba/api"
+require "aruba/cucumber/hooks"
+require "aruba/cucumber/parameter_types"
+require "aruba/cucumber/command"
+require "aruba/cucumber/environment"
+require "aruba/cucumber/file"
+require "aruba/cucumber/testing_frameworks"

data/lib/aruba/cucumber/command.rb

@@ -1,4 +1,4 @@
-require 'aruba/generators/script_file'
+require "aruba/generators/script_file"
 
 When(/^I run `([^`]*)`$/) do |cmd|
   cmd = sanitize_text(cmd)
@@ -14,9 +14,9 @@ end
 
 When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) \
   do |shell, commands|
-  full_path = expand_path('bin/myscript')
+  full_path = expand_path("bin/myscript")
 
-  Aruba.platform.mkdir(expand_path('bin'))
+  Aruba.platform.mkdir(expand_path("bin"))
   shell ||= Aruba.platform.default_shell
 
   Aruba::ScriptFile.new(interpreter: shell, content: commands, path: full_path).call
@@ -32,210 +32,255 @@ 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
-      sleep 0.1
-      retry
-    end
+    expect(last_command_started).to have_output an_output_string_including(expected)
+  rescue ExpectationError
+    sleep 0.1
+    retry
   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
-      sleep 0.1
-      retry
-    end
+    expect(last_command_started).to have_output an_output_string_including(expected)
+  rescue ExpectationError
+    sleep 0.1
+    retry
   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
+            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 = if exactly
-                            :an_output_string_being_eq
-                          else
-                            :an_output_string_including
-                          end
+  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
+            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).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
-            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))
 
-  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).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(combined_output).to send(output_string_matcher, expected)
+  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
-            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))
 
-  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
-            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))
 
-  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
@@ -287,7 +332,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
@@ -299,7 +344,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
@@ -311,7 +356,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
@@ -323,7 +368,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
@@ -335,7 +380,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
@@ -347,7 +392,7 @@ 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
@@ -359,7 +404,7 @@ 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
@@ -371,7 +416,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
@@ -382,9 +427,9 @@ 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
+            when "output"; then :have_output
+            when "stderr"; then :have_output_on_stderr
+            when "stdout"; then :have_output_on_stdout
             end
 
   expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
@@ -394,9 +439,9 @@ 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
@@ -419,7 +464,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 +472,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|
-  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