aruba-win-fix 0.14.2

data/lib/aruba/matchers/collection.rb

@@ -0,0 +1 @@
+Aruba.platform.require_matching_files('../collection/**/*.rb', __FILE__)

data/lib/aruba/matchers/collection/all.rb

@@ -0,0 +1,11 @@
+require 'rspec/expectations'
+
+# Aruba
+module Aruba
+  # Matchers
+  module Matchers
+    include ::RSpec::Matchers
+
+    module_function :all
+  end
+end

data/lib/aruba/matchers/collection/include_an_object.rb

@@ -0,0 +1,122 @@
+require 'aruba/matchers/base/base_matcher'
+
+# Aruba
+module Aruba
+  # Matchers
+  module Matchers
+    # @api private
+    # Provides the implementation for `include_an_object`.
+    # Not intended to be instantiated directly.
+    class IncludeAnObject < BaseMatcher
+      protected
+
+      # @private
+      attr_reader :matcher, :failed_objects
+      # @private
+      attr_accessor :any_succeeded_object
+
+      public
+
+      def initialize(matcher)
+        @matcher              = matcher
+        @failed_objects       = {}
+        @any_succeeded_object = false
+      end
+
+      # @api private
+      # @return [String]
+      def failure_message
+        unless iterable?
+          return "#{improve_hash_formatting(super)}, but was not iterable"
+        end
+
+        all_messages = [improve_hash_formatting(super)]
+        failed_objects.each do |index, matcher_failure_message|
+          all_messages << failure_message_for_item(index, matcher_failure_message)
+        end
+        all_messages.join("\n\n")
+      end
+
+      # @api private
+      # @return [String]
+      def description
+        improve_hash_formatting "include an object #{description_of matcher}"
+      end
+
+      def does_not_match?(actual)
+        @actual = actual
+
+        return false unless iterable?
+
+        index_objects
+
+        any_succeeded_object == false
+      end
+
+      private
+
+      def match(expected, actual)
+        @actual   = actual
+        @expected = expected
+
+        return false unless iterable?
+
+        index_objects
+
+        any_succeeded_object == true
+      end
+
+      def index_objects
+        actual.each_with_index do |actual_item, index|
+          cloned_matcher = matcher.clone
+          begin
+            matches = cloned_matcher.matches?(actual_item)
+          rescue StandardError
+            matches = nil
+          end
+
+          if matches
+            self.any_succeeded_object = true
+            break
+          else
+            failed_objects[index] = cloned_matcher.failure_message
+          end
+        end
+      end
+
+      def failure_message_for_item(index, failure_message)
+        failure_message = indent_multiline_message(add_new_line_if_needed(failure_message))
+        indent_multiline_message("object at index #{index} failed to match:#{failure_message}")
+      end
+
+      def add_new_line_if_needed(message)
+        message.start_with?("\n") ? message : "\n#{message}"
+      end
+
+      def indent_multiline_message(message)
+        message = message.sub(/\n+\z/, '')
+        message.lines.map do |line|
+          line =~ /\S/ ? '   ' + line : line
+        end.join
+      end
+    end
+  end
+end
+
+module RSpec
+  module Matchers
+    # Passes if the provided matcher passes when checked against any
+    # element of the collection.
+    #
+    # @example
+    #   expect([1, 4, 5]).to include_an_object be_odd
+    #
+    # @note You can also use this with compound matchers as well.
+    #
+    # @example
+    #   expect([1, 4, 'a']).to include_an_object( be_odd.and be_an(Integer) )
+    def include_an_object(expected)
+      ::Aruba::Matchers::IncludeAnObject.new(expected)
+    end
+  end
+end

data/lib/aruba/matchers/command.rb

@@ -0,0 +1 @@
+Aruba.platform.require_matching_files('../command/**/*.rb', __FILE__)

data/lib/aruba/matchers/command/be_successfully_executed.rb

@@ -0,0 +1,34 @@
+require 'rspec/expectations/version'
+
+require 'aruba/matchers/command/have_exit_status'
+require 'aruba/matchers/command/have_finished_in_time'
+
+# @!method be_successfuly_executed
+#   This matchers checks if execution of <command> was successful
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command was not successful
+#     true:
+#     * if command was successful
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to be_successfully_executed }
+#       it { expect(last_command_started).not_to be_successfully_executed }
+#       it { expect(last_command_started).to have_failed_running }
+#     end
+RSpec::Matchers.define :be_successfully_executed do
+  match do |actual|
+    @old_actual = actual
+    @actual     = @old_actual.commandline
+
+    expect(@old_actual).to have_exit_status(0)
+  end
+end
+
+if RSpec::Expectations::Version::STRING >= '3.1'
+  RSpec::Matchers.define_negated_matcher :have_failed_running, :be_successfully_executed
+end

data/lib/aruba/matchers/command/have_exit_status.rb

@@ -0,0 +1,38 @@
+# @!method have_exit_status(status)
+#   This matchers checks if <command> has exit status <status>
+#
+#   @param [Integer] status
+#     The value of the exit status
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command does not have exit status
+#     true:
+#     * if command has exit status
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_exit_status(0) }
+#     end
+RSpec::Matchers.define :have_exit_status do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    @old_actual.stop
+    @actual = actual.exit_status
+
+    next false unless @old_actual.respond_to? :exit_status
+
+    values_match? expected, @actual
+  end
+
+  failure_message do |actual|
+    format(%(expected that command "%s" has exit status of "%s", but has "%s".), @old_actual.commandline, expected.to_s, actual.to_s)
+  end
+
+  failure_message_when_negated do |actual|
+    format(%(expected that command "%s" does not have exit status of "%s", but has "%s".), @old_actual.commandline, expected.to_s, actual.to_s)
+  end
+end

data/lib/aruba/matchers/command/have_finished_in_time.rb

@@ -0,0 +1,37 @@
+require 'rspec/expectations/version'
+
+# @!method run_too_long
+#   This matchers checks if <command> run too long. Say the timeout is 10
+#   seconds and it takes <command> to finish in 15. This matchers will succeed.
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command not to run too long
+#     true:
+#     * if command run too long
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to run_too_long }
+#       it { expect(last_command_started).not_to run_too_long }
+#       it { expect(last_command_started).to finish_its_run_in_time }
+#     end
+# RSpec::Matchers.define :run_too_long do
+RSpec::Matchers.define :have_finished_in_time do
+  match do |actual|
+    @old_actual = actual
+    @actual     = @old_actual.commandline
+
+    next false unless @old_actual.respond_to? :timed_out?
+
+    @old_actual.stop
+
+    @old_actual.timed_out? == false
+  end
+end
+
+if RSpec::Expectations::Version::STRING >= '3.1'
+  RSpec::Matchers.define_negated_matcher :run_too_long, :have_finished_in_time
+end

data/lib/aruba/matchers/command/have_output.rb

@@ -0,0 +1,36 @@
+# @!method have_output
+#   This matchers checks if <command> has created output
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output
+#     true:
+#     * if command created output
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output }
+#     end
+RSpec::Matchers.define :have_output do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :output
+
+    @old_actual.stop
+
+    @actual = sanitize_text(actual.output)
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output: #{description_of expected}" }
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :a_command_having_output, :have_output
+end

data/lib/aruba/matchers/command/have_output_on_stderr.rb

@@ -0,0 +1,32 @@
+# @!method have_output_on_stderr
+#   This matchers checks if <command> has created output on stderr
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output on stderr
+#     true:
+#     * if command created output on stderr
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output_on_stderr }
+#     end
+RSpec::Matchers.define :have_output_on_stderr do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :stderr
+
+    @old_actual.stop
+
+    @actual = sanitize_text(actual.stderr)
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output on stderr: #{description_of expected}" }
+end

data/lib/aruba/matchers/command/have_output_on_stdout.rb

@@ -0,0 +1,32 @@
+# @!method have_output_on_stdout
+#   This matchers checks if <command> has created output on stdout
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output on stdout
+#     true:
+#     * if command created output on stdout
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output_on_stdout }
+#     end
+RSpec::Matchers.define :have_output_on_stdout do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :stdout
+
+    @old_actual.stop
+
+    @actual = sanitize_text(actual.stdout)
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output on stdout: #{description_of expected}" }
+end

data/lib/aruba/matchers/command/have_output_size.rb

@@ -0,0 +1,28 @@
+# @!method have_output_size(output)
+#   This matchers checks if output has size.
+#
+#   @param [String] output
+#     The content which should be checked
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if output does not have size
+#     true:
+#     * if output has size
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(file1).to have_output_size(256) }
+#     end
+RSpec::Matchers.define :have_output_size do |expected|
+  match do |actual|
+    next false unless actual.respond_to? :size
+
+    @actual = actual.size
+    values_match? expected, @actual
+  end
+
+  description { "output has size #{description_of expected}" }
+end

data/lib/aruba/matchers/directory.rb

@@ -0,0 +1 @@
+Aruba.platform.require_matching_files('../directory/**/*.rb', __FILE__)

data/lib/aruba/matchers/directory/be_an_existing_directory.rb

@@ -0,0 +1,38 @@
+require 'rspec/expectations/version'
+
+# @!method be_an_existing_directory
+#   This matchers checks if <directory> exists in filesystem
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if directory does not exist
+#     true:
+#     * if directory exists
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(directory1).to be_an_existing_directory }
+#     end
+RSpec::Matchers.define :be_an_existing_directory do |_|
+  match do |actual|
+    stop_all_commands
+
+    next false unless actual.is_a? String
+
+    directory?(actual)
+  end
+
+  failure_message do |actual|
+    format("expected that directory \"%s\" exists", actual)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that directory \"%s\" does not exist", actual)
+  end
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :an_existing_directory, :be_an_existing_directory
+end

data/lib/aruba/matchers/directory/have_sub_directory.rb

@@ -0,0 +1,53 @@
+require 'rspec/expectations/version'
+
+# @!method have_sub_directory(sub_directory)
+#   This matchers checks if <directory> has given sub-directory
+#
+#   @param [Array] sub_directory
+#      A list of sub-directory relative to current directory
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if directory does not have sub-directory
+#     true:
+#     * if directory has sub-directory
+#
+#   @example Use matcher with single directory
+#
+#     RSpec.describe do
+#       it { expect('dir1.d').to have_sub_directory('subdir.1.d') }
+#     end
+#
+#   @example Use matcher with multiple directories
+#
+#     RSpec.describe do
+#       it { expect('dir1.d').to have_sub_directory(['subdir.1.d', 'subdir.2.d']) }
+#       it { expect(directories).to include a_directory_with_sub_directory(['subdir.1.d', 'subdir.2.d']) }
+#     end
+RSpec::Matchers.define :have_sub_directory do |expected|
+  match do |actual|
+    next false unless directory?(actual)
+
+    @old_actual = actual
+    @actual = list(actual)
+
+    @expected = Array(expected).map { |p| File.join(@old_actual, p) }
+
+    (@expected - @actual).empty?
+  end
+
+  diffable
+
+  failure_message do |actual|
+    format("expected that directory \"%s\" has the following sub-directories: %s.", actual.join(', '), expected)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that directory \"%s\" does not have the following sub-directories: %s.", actual.join(', '), expected)
+  end
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :a_directory_having_sub_directory, :have_sub_directory
+end