aruba 2.4.0 → 3.0.0

data/lib/aruba/basic_configuration/option.rb

@@ -13,13 +13,7 @@ module Aruba
       attr_reader :default_value
 
       # Create option
-      def initialize(opts = {})
-        name = opts[:name]
-        value = opts[:value]
-
-        raise ArgumentError, '"name" is required' unless opts.key? :name
-        raise ArgumentError, '"value" is required' unless opts.key? :value
-
+      def initialize(name:, value:)
         @name          = name
         @value         = value
         @default_value = value

data/lib/aruba/basic_configuration.rb

@@ -19,13 +19,10 @@ module Aruba
 
       # Define an option reader
       #
-      # @param [Symbol] name
-      #   The name of the reader
-      #
-      # @option [Class, Module] type
+      # @param [Class, Module] type
       #   The type contract for the option
       #
-      # @option [Object] default
+      # @param [Object] default
       #   The default value
       def option_reader(name, type:, default: nil)
         raise ArgumentError, 'Either use block or default value' if block_given? && default
@@ -38,13 +35,10 @@ module Aruba
 
       # Define an option reader and writer
       #
-      # @param [Symbol] name
-      #   The name of the reader
-      #
-      # @option [Class, Module] type
+      # @param [Class, Module] type
       #   The type contract for the option
       #
-      # @option [Object] default
+      # @param [Object] default
       #   The default value
       #
       def option_accessor(name, type:, default: nil)
@@ -56,14 +50,14 @@ module Aruba
         Contract type => type
         define_method(:"#{name}=") { |v| find_option(name).value = v }
 
-        # Add reader
-        option_reader name, type: type
+        Contract None => type
+        define_method(name) { find_option(name).value }
       end
 
       private
 
       def add_option(name, value = nil)
-        return if known_options.key?(name)
+        raise "Option #{name} already exists" if known_options.key?(name)
 
         known_options[name] = Option.new(name: name, value: value)
 

data/lib/aruba/cli.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'thor'
-require 'aruba/console'
 require 'aruba/initializer'
 
 # Aruba
@@ -14,11 +13,6 @@ module Aruba
       true
     end
 
-    desc 'console', "Start aruba's console"
-    def console
-      Aruba::Console.new.start
-    end
-
     desc 'init', 'Initialize aruba'
     option :test_framework,
            default: 'cucumber',

data/lib/aruba/command.rb

@@ -24,30 +24,30 @@ module Aruba
 
     public
 
-    def initialize(command, opts = {})
-      launchers = []
-      launchers << Processes::DebugProcess
-      launchers << Processes::InProcess
-      launchers << Processes::SpawnProcess
+    LAUNCHERS = [
+      Processes::DebugProcess,
+      Processes::InProcess,
+      Processes::SpawnProcess
+    ].freeze
 
-      klass = launchers.find { |l| l.match? opts[:mode] }
+    def initialize(command, exit_timeout:, io_wait_timeout:, working_directory:, environment:, # rubocop:disable Metrics/ParameterLists
+                   main_class:, stop_signal:, startup_wait_time:, event_bus:, mode: nil)
+      klass = LAUNCHERS.find { |l| l.match? mode }
 
       launcher = klass.new(
         command,
-        opts.fetch(:exit_timeout),
-        opts.fetch(:io_wait_timeout),
-        opts.fetch(:working_directory),
-        opts.fetch(:environment),
-        opts.fetch(:main_class),
-        opts.fetch(:stop_signal),
-        opts.fetch(:startup_wait_time)
+        exit_timeout,
+        io_wait_timeout,
+        working_directory,
+        environment,
+        main_class,
+        stop_signal,
+        startup_wait_time
       )
 
       super(launcher)
 
-      @event_bus = opts.fetch(:event_bus)
-    rescue KeyError => e
-      raise ArgumentError, e.message
+      @event_bus = event_bus
     end
 
     # Stop command

data/lib/aruba/command_monitor.rb

@@ -44,14 +44,12 @@ module Aruba
       end
     end
 
-    def initialize(opts = {})
+    def initialize(announcer:)
       @registered_commands = []
-      @announcer = opts.fetch(:announcer)
+      @announcer = announcer
 
       @last_command_stopped = DefaultLastCommandStopped.new
       @last_command_started = DefaultLastCommandStarted.new
-    rescue KeyError => e
-      raise ArgumentError, e.message
     end
 
     # Set last command started

data/lib/aruba/configuration.rb

@@ -7,23 +7,43 @@ require 'aruba/basic_configuration'
 require 'aruba/in_config_wrapper'
 require 'aruba/hooks'
 
-require 'aruba/contracts/relative_path'
-require 'aruba/contracts/absolute_path'
-require 'aruba/contracts/enum'
-
-require 'aruba/contracts/is_power_of_two'
-
 # Aruba
 module Aruba
   # Aruba Configuration
   #
   # This defines the configuration options of aruba
   class Configuration < BasicConfiguration
+    #
+    # Custom Contracts go here
+    #
+
+    # Value is a single safe relative path segment. Joining it to a path must
+    # yield a strict subdirectory of that path.
+    # @private
+    class PathSegment
+      def self.valid?(value)
+        test_path = Pathname.new('test').join(value).cleanpath
+        test_path.basename.to_s == value
+      rescue StandardError
+        false
+      end
+    end
+
+    # Value is a power of two
+    # @private
+    class IsPowerOfTwo
+      def self.valid?(value)
+        # explanation for algorithm can be found here:
+        # http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/
+        value.positive? && value.nobits?(value - 1)
+      rescue StandardError
+        false
+      end
+    end
+
     option_reader :root_directory, type: String, default: Dir.getwd
 
-    option_accessor :working_directory,
-                    type: Aruba::Contracts::RelativePath,
-                    default: 'tmp/aruba'
+    option_accessor :working_directory_suffix, type: PathSegment, default: 'aruba'
 
     option_reader :fixtures_path_prefix, type: String, default: '%'
 
@@ -43,27 +63,19 @@ module Aruba
                     end
     option_accessor :remove_ansi_escape_sequences, type: Bool, default: true
     option_accessor :command_launcher,
-                    type: Aruba::Contracts::Enum[:in_process, :spawn, :debug],
+                    type: Enum[:in_process, :spawn, :debug],
                     default: :spawn
     option_accessor :main_class, type: Maybe[Class], default: nil
 
-    option_accessor :home_directory,
-                    type: Or[Aruba::Contracts::AbsolutePath,
-                             Aruba::Contracts::RelativePath] do |config|
-      File.join(config.root_directory.value, config.working_directory.value)
-    end
-
     option_accessor :log_level,
-                    type:
-                        Aruba::Contracts::Enum[:fatal, :warn, :debug, :info,
-                                               :error, :unknown, :silent],
+                    type: Enum[:fatal, :warn, :debug, :info, :error, :unknown, :silent],
                     default: :info
 
     # TODO: deprecate this value and replace with "filesystem allocation unit"
     # equal to 4096 by default. "filesystem allocation unit" would represent
     # the actual MINIMUM space taken in bytes by a 1-byte file
     option_accessor :physical_block_size,
-                    type: Aruba::Contracts::IsPowerOfTwo,
+                    type: IsPowerOfTwo,
                     default: 512
     option_accessor :console_history_file, type: String,
                                            default: '~/.aruba_history'

data/lib/aruba/cucumber/command.rb

@@ -44,12 +44,6 @@ When 'I run {command} in the background' do |cmd|
   run_command(sanitize_text(cmd))
 end
 
-When 'I run {command} in background' do |cmd|
-  Aruba.platform.deprecated \
-    'This cucumber step is deprecated. Use "I run {command} in the background" instead.'
-  run_command(sanitize_text(cmd))
-end
-
 When 'I type {string}' do |input|
   type(unescape_text(input))
 end
@@ -82,7 +76,6 @@ end
 
 When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) \
   do |channel, expected|
-
   start_time = Time.now
   loop do
     output = last_command_started.public_send channel.to_sym, wait_for_io: 0
@@ -105,7 +98,7 @@ When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$
   end
 end
 
-When 'I wait for output/stdout to contain:' do |expected|
+When 'I wait for (the )output/stdout to contain:' do |expected|
   start_time = Time.now
   loop do
     output = last_command_started.stdout wait_for_io: 0
@@ -124,7 +117,7 @@ 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 (the )output/stdout to contain {string}' do |expected|
   start_time = Time.now
   loop do
     output = last_command_started.stdout wait_for_io: 0
@@ -151,28 +144,28 @@ end
 Then '(the ){channel} should contain {string}' do |channel, expected|
   combined_output = send(:"all_#{channel}")
 
-  expect(combined_output).to include_output_string expected
+  expect(extract_text(combined_output)).to include 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
+  expect(extract_text(combined_output)).not_to include 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
+  expect(sanitize_text(combined_output)).to 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
+  expect(sanitize_text(combined_output)).not_to eq expected
 end
 
 ## the stderr from "echo -n 'Hello'" should contain "hello"
@@ -185,9 +178,7 @@ Then '(the ){channel} from {string} should contain {string}' do |channel, cmd, e
 
   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))
+  expect(command).to send(matcher, a_string_including(expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should contain exactly "hello"
@@ -201,9 +192,7 @@ Then '(the ){channel} from {string} should contain exactly {string}' \
 
   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))
+  expect(command).to send(matcher, expected)
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain "hello"
@@ -216,9 +205,7 @@ Then '(the ){channel} from {string} should not contain {string}' do |channel, cm
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = :an_output_string_including
-
-  expect(command).not_to send(matcher, send(output_string_matcher, expected))
+  expect(command).not_to send(matcher, a_string_including(expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly "hello"
@@ -232,37 +219,37 @@ Then '(the ){channel} from {string} should not contain exactly {string}' \
 
   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))
+  expect(command).not_to send(matcher, expected)
 end
 
 ## the stderr should contain:
 Then '(the ){channel} should contain:' do |channel, expected|
   combined_output = send(:"all_#{channel}")
 
-  expect(combined_output).to include_output_string(expected)
+  expect(extract_text(combined_output)).to include(expected)
 end
 
 ## 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)
+  expect(extract_text(combined_output)).not_to include(expected)
 end
 
 ## the stderr should contain exactly:
 Then '(the ){channel} should contain exactly:' do |channel, expected|
+  expected = unescape_text(expected)
   combined_output = send(:"all_#{channel}")
 
-  expect(combined_output).to output_string_eq(expected)
+  expect(sanitize_text(combined_output)).to eq expected
 end
 
 ## the stderr should not contain exactly:
 Then '(the ){channel} should not contain exactly:' do |channel, expected|
+  expected = unescape_text(expected)
   combined_output = send(:"all_#{channel}")
 
-  expect(combined_output).not_to output_string_eq(expected)
+  expect(sanitize_text(combined_output)).not_to eq expected
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain:
@@ -275,9 +262,7 @@ Then '(the ){channel} from {string} should not contain:' do |channel, cmd, expec
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
-  output_string_matcher = :an_output_string_including
-
-  expect(command).not_to send(matcher, send(output_string_matcher, expected))
+  expect(command).not_to send(matcher, a_string_including(expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly:
@@ -290,9 +275,7 @@ Then '(the ){channel} from {string} should not contain exactly:' do |channel, cm
 
   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))
+  expect(command).not_to send(matcher, expected)
 end
 
 ## the stderr from "echo -n 'Hello'" should contain:
@@ -305,9 +288,7 @@ Then '(the ){channel} from {string} should contain:' do |channel, cmd, expected|
 
   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))
+  expect(command).to send(matcher, a_string_including(expected))
 end
 
 ## the stderr from "echo -n 'Hello'" should contain exactly:
@@ -320,9 +301,7 @@ Then '(the ){channel} from {string} should contain exactly:' do |channel, cmd, e
 
   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))
+  expect(command).to send(matcher, expected)
 end
 
 # "the output should match" allows regex in the partial_output, if
@@ -331,31 +310,25 @@ end
 # appear naturally in the output
 Then(%r{^the output should( not)? match /([^/]*)/$}) do |negated, expected|
   if negated
-    expect(all_commands)
-      .not_to include have_output an_output_string_matching(expected)
+    expect(all_output).not_to match_output_string(expected)
   else
-    expect(all_commands)
-      .to include have_output an_output_string_matching(expected)
+    expect(all_output).to match_output_string(expected)
   end
 end
 
 Then(/^the output should( not)? match %r<([^>]*)>$/) do |negated, expected|
   if negated
-    expect(all_commands)
-      .not_to include have_output an_output_string_matching(expected)
+    expect(all_output).not_to match_output_string(expected)
   else
-    expect(all_commands)
-      .to include have_output an_output_string_matching(expected)
+    expect(all_output).to match_output_string(expected)
   end
 end
 
 Then(/^the output should( not)? match:$/) do |negated, expected|
   if negated
-    expect(all_commands)
-      .not_to include have_output an_output_string_matching(expected)
+    expect(all_output).not_to match_output_string(expected)
   else
-    expect(all_commands)
-      .to include have_output an_output_string_matching(expected)
+    expect(all_output).to match_output_string(expected)
   end
 end
 
@@ -393,21 +366,6 @@ Then(/^it should (pass|fail)$/) do |pass_fail|
   end
 end
 
-Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
-  Aruba.platform.deprecated \
-    'This cucumber step has confusing behavior and is deprecated.' \
-    "Use 'it should #{pass_fail}' with a negative output matcher step instead."
-  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
-
-  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
 
@@ -417,22 +375,7 @@ Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, 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 |pass_fail, expected|
-  Aruba.platform.deprecated \
-    'This cucumber step has confusing behavior and is deprecated.' \
-    "Use 'it should #{pass_fail}' with a negative output matcher step instead."
-  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
-
-  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).to have_output a_string_including(expected)
 end
 
 Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
@@ -444,22 +387,7 @@ Then(/^it should (pass|fail) with:$/) do |pass_fail, 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 |pass_fail, expected|
-  Aruba.platform.deprecated \
-    'This cucumber step has confusing behavior and is deprecated.' \
-    "Use 'it should #{pass_fail}' with a negative output matcher step instead."
-  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
-
-  expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+  expect(last_command_stopped).to have_output a_string_including(expected)
 end
 
 Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
@@ -471,22 +399,7 @@ Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  expect(last_command_stopped.output).to output_string_eq(expected)
-end
-
-Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
-  Aruba.platform.deprecated \
-    'This cucumber step has confusing behavior and is deprecated.' \
-    "Use 'it should #{pass_fail}' with a negative output matcher step instead."
-  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
-
-  expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+  expect(last_command_stopped).to have_output expected
 end
 
 Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
@@ -504,7 +417,7 @@ end
 Then '(the ){channel} should not contain anything' do |channel|
   combined_output = send(:"all_#{channel}")
 
-  expect(combined_output).to output_string_eq ''
+  expect(extract_text(combined_output)).to eq ''
 end
 
 Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) \
@@ -518,10 +431,10 @@ Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:
 
     if negated
       expect(all_commands)
-        .not_to include send(matcher, an_output_string_including(expected))
+        .not_to include send(matcher, a_string_including(expected))
     else
       expect(all_commands)
-        .to include send(matcher, an_output_string_including(expected))
+        .to include send(matcher, a_string_including(expected))
     end
   end
 end

data/lib/aruba/cucumber/environment.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-Given(/^a mocked home directory$/) do
-  set_environment_variable 'HOME', expand_path('.')
-end
-
 Given(/^I set the environment variable "(.*)" to "(.*)"/) do |variable, value|
   set_environment_variable(variable.to_s, value.to_s)
 end

data/lib/aruba/cucumber/file.rb

@@ -121,9 +121,9 @@ end
 
 Then(/^(?:a|the) file matching %r<(.*?)> should (not )?exist$/) do |pattern, expect_match|
   if expect_match
-    expect(all_paths).not_to include a_file_name_matching(pattern)
+    expect(all_paths).not_to include a_string_matching(pattern)
   else
-    expect(all_paths).to include match a_file_name_matching(pattern)
+    expect(all_paths).to include a_string_matching(pattern)
   end
 end
 
@@ -149,18 +149,18 @@ end
 Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain "([^"]*)"$/) \
   do |file, negated, content|
   if negated
-    expect(file).not_to have_file_content file_content_including(content.chomp)
+    expect(file).not_to have_file_content a_string_including(content.chomp)
   else
-    expect(file).to have_file_content file_content_including(content.chomp)
+    expect(file).to have_file_content a_string_including(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 file_content_including(content.chomp)
+    expect(file).not_to have_file_content a_string_including(content.chomp)
   else
-    expect(file).to have_file_content file_content_including(content.chomp)
+    expect(file).to have_file_content a_string_including(content.chomp)
   end
 end
 
@@ -176,18 +176,18 @@ end
 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)
+    expect(file).not_to have_file_content Regexp.new(content)
   else
-    expect(file).to have_file_content file_content_matching(content)
+    expect(file).to have_file_content Regexp.new(content)
   end
 end
 
 Then(%r{^(?:a|the) file(?: named)? "([^"]*)" should (not )?match /([^/]*)/$}) \
   do |file, negated, content|
   if negated
-    expect(file).not_to have_file_content file_content_matching(content)
+    expect(file).not_to have_file_content Regexp.new(content)
   else
-    expect(file).to have_file_content file_content_matching(content)
+    expect(file).to have_file_content Regexp.new(content)
   end
 end