aruba 0.9.0.pre → 0.9.0.pre2

data/lib/aruba/cucumber/command.rb

@@ -0,0 +1,378 @@
+When(/^I run "(.*)"$/)do |cmd|
+  warn(%{\e[35m    The /^I run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
+
+  cmd = unescape_text(cmd)
+  cmd = extract_text(cmd) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  run_simple(cmd, false)
+end
+
+When(/^I run `([^`]*)`$/)do |cmd|
+  cmd = unescape_text(cmd)
+  cmd = extract_text(cmd) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  run_simple(cmd, false)
+end
+
+When(/^I successfully run "(.*)"$/)do |cmd|
+  warn(%{\e[35m    The  /^I successfully run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
+
+  cmd = unescape_text(cmd)
+  cmd = extract_text(cmd) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  run_simple(cmd)
+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 = unescape_text(cmd)
+  cmd = extract_text(cmd) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  run_simple(cmd, true, secs && secs.to_i)
+end
+
+When(/^I run "([^"]*)" interactively$/) do |cmd|
+  Aruba.platform.deprecated(%{\e[35m    The /^I run "([^"]*)" interactively$/ step definition is deprecated. Please use the `backticks` version\e[0m})
+
+  step %(I run `#{cmd}` interactively)
+end
+
+When(/^I run `([^`]*)` interactively$/)do |cmd|
+  cmd = unescape_text(cmd)
+  cmd = extract_text(cmd) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  @interactive = run(cmd)
+end
+
+When(/^I type "([^"]*)"$/) do |input|
+  type(unescape_text(input))
+end
+
+When(/^I close the stdin stream$/) do
+  close_input
+end
+
+When(/^I pipe in (?:a|the) file(?: named)? "([^"]*)"$/) do |file|
+  pipe_in_file(file)
+
+  close_input
+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 = unescape_text(output)
+        output = extract_text(output) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+        expected = unescape_text(expected)
+        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+        if output.include? expected
+          last_command_started.terminate
+
+          break
+        end
+
+        sleep 0.1
+      end
+    end
+  rescue ChildProcess::TimeoutError, TimeoutError
+    last_command_started.terminate
+  ensure
+    announcer.announce :stdout, last_command_started.stdout
+    announcer.announce :stderr, last_command_started.stderr
+  end
+end
+
+When(/^I wait for (?:output|stdout) to contain:$/) do |expected|
+  Timeout.timeout(exit_timeout) do
+    loop do
+      begin
+        expected = unescape_text(expected)
+        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+        expect(last_command_started).to have_output Regexp.new(expected)
+      rescue ExpectationError
+        sleep 0.1
+        retry
+      end
+
+      break
+    end
+  end
+end
+
+When(/^I wait for (?:output|stdout) to contain "([^"]*)"$/) do |expected|
+  Timeout.timeout(exit_timeout) do
+    loop do
+      begin
+        expected = unescape_text(expected)
+        expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+        expect(last_command_started).to have_output Regexp.new(expected)
+      rescue ExpectationError
+        sleep 0.1
+        retry
+      end
+
+      break
+    end
+  end
+end
+
+Then(/^the output should be (\d+) bytes long$/) do |size|
+  expect(all_output).to have_output_size size.to_i
+end
+
+Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
+  matcher = case channel.to_sym
+            when :output
+              :have_output
+            when :stderr
+              :have_output_on_stderr
+            when :stdout
+              :have_output_on_stdout
+            end
+
+  commands = if cmd
+               [process_monitor.get_process(Aruba.platform.detect_ruby(cmd))]
+             else
+               all_commands
+             end
+
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  expected = if exactly
+               expected
+             else
+               Regexp.new(Regexp.escape(expected))
+             end
+
+  if Aruba::VERSION < '1.0'
+    combined_output = commands.map do |c|
+      c.stop(announcer)
+      c.send(channel.to_sym).chomp
+    end.join("\n")
+
+    if negated
+      expect(combined_output).not_to match expected
+    else
+      expect(combined_output).to match expected
+    end
+  else
+    if negated
+      expect(commands).not_to include_an_object send(matcher, expected)
+    else
+      expect(commands).to include_an_object send(matcher, expected)
+    end
+  end
+end
+
+## the stderr should contain "hello"
+## the stderr from "echo -n 'Hello'" should contain "hello"
+## the stderr should contain exactly:
+## the stderr from "echo -n 'Hello'" should contain exactly:
+Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain( exactly)?:$/) do |channel, cmd, negated, exactly, 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", "stderr" or "stdout" are allowed.)
+            end
+
+  commands = if cmd
+               [process_monitor.get_process(Aruba.platform.detect_ruby(cmd))]
+             else
+               all_commands
+             end
+
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  expected = if exactly
+               expected
+             else
+               Regexp.new(Regexp.escape(expected))
+             end
+
+  if Aruba::VERSION < '1.0'
+    combined_output = commands.map do |c|
+      c.stop(announcer)
+      c.send(channel.to_sym).chomp
+    end.join("\n")
+
+    if negated
+      expect(combined_output).not_to match expected
+    else
+      expect(combined_output).to match expected
+    end
+  else
+    if negated
+      expect(commands).not_to include_an_object send(matcher, expected)
+    else
+      expect(commands).to include_an_object send(matcher, expected)
+    end
+  end
+end
+
+# "the output should match" allows regex in the partial_output, if
+# you don't need regex, use "the output should contain" instead since
+# that way, you don't have to escape regex characters that
+# appear naturally in the output
+Then(/^the output should( not)? match \/([^\/]*)\/$/) do |negated, expected|
+  if negated
+    expect(all_commands).not_to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  else
+    expect(all_commands).to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  end
+end
+
+Then(/^the output should( not)? match %r<([^>]*)>$/) do |negated, expected|
+  if negated
+    expect(all_commands).not_to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  else
+    expect(all_commands).to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  end
+end
+
+Then(/^the output should( not)? match:$/) do |negated, expected|
+  if negated
+    expect(all_commands).not_to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  else
+    expect(all_commands).to include_an_object have_output Regexp.new(expected, Regexp::MULTILINE)
+  end
+end
+
+Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
+  if negated
+    expect(last_command_stopped).not_to have_exit_status exit_status.to_i
+  else
+    expect(last_command_stopped).to have_exit_status exit_status.to_i
+  end
+end
+
+Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expected|
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+  expected = Regexp.new(Regexp.escape(expected))
+
+  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 expected
+  else
+    expect(last_command_stopped).to have_output expected
+  end
+end
+
+Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+  expected = Regexp.new(Regexp.escape(expected))
+
+  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 expected
+  else
+    expect(last_command_stopped).to have_output expected
+  end
+end
+
+Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, expected|
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  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 expected
+  else
+    expect(last_command_stopped).to have_output expected
+  end
+end
+
+Then(/^it should( not)? (pass|fail) with regexp?:$/) do |negated, pass_fail, expected|
+  expected = unescape_text(expected).chomp
+  expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+  expected = Regexp.new(expected, Regexp::MULTILINE)
+
+  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 expected
+  else
+    expect(last_command_stopped).to have_output expected
+  end
+end
+
+Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channel|
+  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
+
+  expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
+end
+
+Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) do |channel, negated, table|
+  table.raw.flatten.each do |expected|
+    expected = unescape_text(expected).chomp
+    expected = extract_text(expected) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+    expected = Regexp.new(Regexp.escape(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
+
+    if negated
+      expect(all_commands).not_to include_an_object send(matcher, expected)
+    else
+      expect(all_commands).to include_an_object send(matcher, expected)
+    end
+  end
+end

data/lib/aruba/cucumber/core.rb

@@ -0,0 +1,29 @@
+if Aruba::VERSION >= '1.0.0'
+  Aruba.configure do |config|
+    config.working_directory = 'tmp/cucumber'
+  end
+end
+
+Given(/the default aruba timeout is (\d+) seconds/) do |seconds|
+  # rubocop:disable Metrics/LineLength
+  Aruba.platform.deprecated(%{The /^the default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use /^the default aruba exit timeout is (\d+) seconds/ step definition is deprecated.})
+  # rubocop:enable Metrics/LineLength
+
+  aruba.config.exit_timeout = seconds.to_i
+end
+
+Given(/The default aruba timeout is (\d+) seconds/) do |seconds|
+  # rubocop:disable Metrics/LineLength
+  Aruba.platform.deprecated(%{The /^The default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use /^the default aruba exit timeout is (\d+) seconds/ step definition is deprecated.})
+  # rubocop:enable Metrics/LineLength
+
+  aruba.config.exit_timeout = seconds.to_i
+end
+
+Given(/the default aruba io wait timeout is (\d+) seconds/) do |seconds|
+  aruba.config.io_wait_timeout = seconds.to_i
+end
+
+Given(/the default aruba exit timeout is (\d+) seconds/) do |seconds|
+  aruba.config.exit_timeout = seconds.to_i
+end

data/lib/aruba/cucumber/environment.rb

@@ -0,0 +1,30 @@
+Given(/^a mocked home directory$/)do
+  set_environment_variable 'HOME', expand_path('.')
+end
+
+Given(/^I set the environment variables? to:/) do |table|
+  table.hashes.each do |row|
+    variable = row['variable'].to_s.upcase
+    value = row['value'].to_s
+
+    set_environment_variable(variable, value)
+  end
+end
+
+Given(/^I append the values? to the environment variables?:/) do |table|
+  table.hashes.each do |row|
+    variable = row['variable'].to_s.upcase
+    value = row['value'].to_s
+
+    append_environment_variable(variable, value)
+  end
+end
+
+Given(/^I prepend the values? to the environment variables?:/) do |table|
+  table.hashes.each do |row|
+    variable = row['variable'].to_s.upcase
+    value = row['value'].to_s
+
+    prepend_environment_variable(variable, value)
+  end
+end

data/lib/aruba/cucumber/file.rb

@@ -0,0 +1,210 @@
+Given(/^I use (?:a|the) fixture(?: named)? "([^"]*)"$/) do |name|
+  copy File.join(aruba.config.fixtures_path_prefix, name), name
+  cd name
+end
+
+Given(/^I copy (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+  copy source, destination
+end
+
+Given(/^I move (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+  move source, destination
+end
+
+Given(/^(?:a|the) directory(?: named)? "([^"]*)"$/) do |dir_name|
+  create_directory(dir_name)
+end
+
+Given(/^(?:a|the) directory(?: named)? "([^"]*)" with mode "([^"]*)"$/) do |dir_name, dir_mode|
+  create_directory(dir_name)
+  chmod(dir_mode, dir_name)
+end
+
+Given(/^(?:a|the) file(?: named)? "([^"]*)" with:$/) do |file_name, file_content|
+  write_file(file_name, file_content)
+end
+
+Given(/^(?:an|the) executable(?: named)? "([^"]*)" with:$/) do |file_name, file_content|
+  step %(a file named "#{file_name}" with mode "0755" and with:), file_content
+end
+
+Given(/^(?:a|the) file(?: named)? "([^"]*)" with "([^"]*)"$/) do |file_name, file_content|
+  file_content = unescape_text(file_content)
+  file_content = extract_text(file_content) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+  write_file(file_name, file_content)
+end
+
+Given(/^(?:a|the) file(?: named)? "([^"]*)" with mode "([^"]*)" and with:$/) do |file_name, file_mode, file_content|
+  write_file(file_name, file_content)
+  chmod(file_mode, file_name)
+end
+
+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|the) empty file(?: named)? "([^"]*)"$/) do |file_name|
+  write_file(file_name, "")
+end
+
+Given(/^(?:an|the) empty file(?: named)? "([^"]*)" with mode "([^"]*)"$/) do |file_name, file_mode|
+  write_file(file_name, "")
+  chmod(file_mode, file_name)
+end
+
+Given(/^(?:a|the) directory(?: named)? "([^"]*)" does not exist$/) do |directory_name|
+  remove(directory_name, :force => true)
+end
+
+When(/^I write to "([^"]*)" with:$/) do |file_name, file_content|
+  write_file(file_name, file_content)
+end
+
+When(/^I overwrite(?: (?:a|the) file(?: named)?)? "([^"]*)" with:$/) do |file_name, file_content|
+  overwrite_file(file_name, file_content)
+end
+
+When(/^I append to "([^"]*)" with:$/) do |file_name, file_content|
+  append_to_file(file_name, file_content)
+end
+
+When(/^I append to "([^"]*)" with "([^"]*)"$/) do |file_name, file_content|
+  append_to_file(file_name, file_content)
+end
+
+When(/^I remove (?:a|the) file(?: named)? "([^"]*)"$/) do |file_name|
+  remove(file_name)
+end
+
+Given(/^(?:a|the) file(?: named)? "([^"]*)" does not exist$/) do |file_name|
+  remove(file_name, :force => true)
+end
+
+When(/^I remove (?:a|the) directory(?: named)? "(.*?)"$/) do |directory_name|
+  remove(directory_name)
+end
+
+When(/^I cd to "([^"]*)"$/) do |dir|
+  cd(dir)
+end
+
+Then(/^the following files should (not )?exist:$/) do |negated, files|
+  files = files.rows.flatten
+
+  if negated
+    expect(files).not_to include an_existing_file
+  else
+    expect(files).to all_objects be_an_existing_file
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?exist$/) do |file, expect_match|
+  if expect_match
+    expect(file).not_to be_an_existing_file
+  else
+    expect(file).to be_an_existing_file
+  end
+end
+
+Then(/^(?:a|the) file matching %r<(.*?)> should (not )?exist$/) do |pattern, expect_match|
+  if expect_match
+    expect(all_paths).not_to include match Regexp.new(pattern)
+  else
+    expect(all_paths).to include match Regexp.new(pattern)
+  end
+end
+
+Then(/^(?:a|the) (\d+) byte file(?: named)? "([^"]*)" should (not )?exist$/) do |size, file, negated|
+  if negated
+    expect(file).not_to have_file_size(size)
+  else
+    expect(file).to have_file_size(size)
+  end
+end
+
+Then(/^the following directories should (not )?exist:$/) do |negated, directories|
+  directories = directories.rows.flatten
+
+  if negated
+    expect(directories).not_to include an_existing_directory
+  else
+    expect(directories).to all_objects be_an_existing_directory
+  end
+end
+
+Then(/^(?:a|the) directory(?: named)? "([^"]*)" should (not )?exist$/) do |directory, negated|
+  if negated
+    expect(directory).not_to be_an_existing_directory
+  else
+    expect(directory).to be_an_existing_directory
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain "([^"]*)"$/) do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(Regexp.escape(content.chomp))
+  else
+    expect(file).to have_file_content Regexp.new(Regexp.escape(content.chomp))
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain:$/) do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(Regexp.escape(content.chomp))
+  else
+    expect(file).to have_file_content Regexp.new(Regexp.escape(content.chomp))
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain exactly:$/) do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content content
+  else
+    expect(file).to have_file_content content
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match %r<([^\/]*)>$/) do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(content)
+  else
+    expect(file).to have_file_content Regexp.new(content)
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match \/([^\/]*)\/$/) do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(content)
+  else
+    expect(file).to have_file_content Regexp.new(content)
+  end
+end
+
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?be equal to file "([^"]*)"/) do |file, negated, reference_file|
+  if negated
+    expect(file).not_to have_same_file_content_like(reference_file)
+  else
+    expect(file).to have_same_file_content_like(reference_file)
+  end
+end
+
+Then(/^the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)"$/) do |file, negated, permissions|
+  # rubocop:disable Metrics/LineLength
+  Aruba.platform.deprecated('The use of step "the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)" is deprecated. Use "^the (?:file|directory)(?: named)? "([^"]*)" should have permissions "([^"]*)"$" instead')
+  # rubocop:enable Metrics/LineLength
+
+  if negated
+    expect(file).not_to have_permissions(permissions)
+  else
+    expect(file).to have_permissions(permissions)
+  end
+end
+
+Then(/^the (?:file|directory)(?: named)? "([^"]*)" should( not)? have permissions "([^"]*)"$/) do |path, negated, permissions|
+  if negated
+    expect(path).not_to have_permissions(permissions)
+  else
+    expect(path).to have_permissions(permissions)
+  end
+end