aruba 0.6.2 → 0.7.0

data/lib/aruba/matchers/directory.rb

@@ -0,0 +1,59 @@
+
+RSpec::Matchers.define :be_existing_directory do |_|
+  match do |actual|
+    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
+
+# @!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']) }
+#     end
+RSpec::Matchers.define :have_sub_directory do |expected|
+  match do |actual|
+    next false unless directory?(actual)
+
+    expected_files = Array(expected).map { |p| File.join(actual, p) }
+    existing_files = list(actual)
+
+    (expected_files - existing_files).empty?
+  end
+
+  diffable
+
+  failure_message do |actual|
+    format("expected that directory \"%s\" has the following sub-directories: %s.", actual, Array(expected).join(', '))
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that directory \"%s\" does not have the following sub-directories: %s.", actual, Array(expected).join(', '))
+  end
+end

data/lib/aruba/matchers/file.rb

@@ -0,0 +1,177 @@
+# @!method have_same_file_content_like(file_name)
+#   This matchers checks if <file1> has the same content like <file2>
+#
+#   @param [String] file_name
+#     The name of the file which should be compared with the file in the
+#     `expect()`-call.
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if file1 is not equal file2
+#     true:
+#     * if file1 is equal file2
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(file1).to have_same_file_content_like(file2) }
+#     end
+RSpec::Matchers.define :have_same_file_content_like do |expected|
+  match do |actual|
+    FileUtils.compare_file(
+      expand_path(actual),
+      expand_path(expected)
+    )
+  end
+
+  failure_message do |actual|
+    format("expected that file \"%s\" is the same as file \"%s\".", actual, expected)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that file \"%s\" differs from file \"%s\".", actual, expected)
+  end
+end
+
+# @!method be_existing_file
+#   This matchers checks if <file> exists in filesystem
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if file does not exist
+#     true:
+#     * if file exists
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(file1).to be_existing_file }
+#     end
+RSpec::Matchers.define :be_existing_file do |_|
+  match do |actual|
+    next false unless actual.is_a? String
+
+    file?(actual)
+  end
+
+  failure_message do |actual|
+    format("expected that file \"%s\" exists", actual)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that file \"%s\" does not exist", actual)
+  end
+end
+
+# @!method be_existing_files
+#   This matchers checks if <files> exists in filessystem
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if files does not exist
+#     true:
+#     * if files exists
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(%w(file1 file2)).to be_existing_files }
+#     end
+RSpec::Matchers.define :be_existing_files do |_|
+  match do |actual|
+    next false unless actual.is_a? Array
+
+    actual.all? { |f| file?(f) }
+  end
+
+  failure_message do |actual|
+    format("expected that files \"%s\" exists", actual.join(', '))
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that files \"%s\" does not exist", actual.join(', '))
+  end
+end
+
+# @!method have_file_content(content)
+#   This matchers checks if <file> has content. `content` can be a string,
+#   regexp or an RSpec matcher.
+#
+#   @param [String, Regexp, Matcher] content
+#     Specifies the content of the file
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if file does not exist
+#     * if file content is not equal string
+#     * if file content does not include regexp
+#     * if file content does not match the content specification
+#
+#     true:
+#     * if file content includes regexp
+#     * if file content is equal string
+#     * if file content matches the content specification
+#
+#   @example Use matcher with string
+#
+#     RSpec.describe do
+#       it { expect(file1).to have_file_content('a') }
+#     end
+#
+#   @example Use matcher with regexp
+#
+#     RSpec.describe do
+#       it { expect(file1).to have_file_content(/a/) }
+#     end
+#
+#   @example Use matcher with an RSpec matcher
+#
+#     RSpec.describe do
+#       it { expect(file1).to have_file_content(a_string_starting_with 'a') }
+#     end
+RSpec::Matchers.define :have_file_content do |expected|
+  match do |actual|
+    next false unless file? actual
+
+    values_match?(expected, File.read(expand_path(actual)).chomp)
+  end
+
+  description { "have file content: #{description_of expected}" }
+end
+
+# @!method have_file_size(size)
+#   This matchers checks if path has file size
+#
+#   @param [Fixnum] size
+#     The size to check
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if path does not have size
+#     true:
+#     * if path has size
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect('file.txt').to have_file_size(0) }
+#     end
+RSpec::Matchers.define :have_file_size do |expected|
+  match do |actual|
+    next false unless File.file? expand_path(actual)
+    File.size(expand_path(actual)) == expected
+  end
+
+  failure_message do |actual|
+    format("expected that file \"%s\" has size \"%s\", but has \"%s\"", actual, File.size(expand_path(actual)), expected)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that file \"%s\" does not have size \"%s\", but has \"%s\"", actual, File.size(expand_path(actual)), expected)
+  end
+end

data/lib/aruba/matchers/mode.rb

@@ -0,0 +1,52 @@
+# @!method have_permissions(permissions)
+#   This matchers checks if <file> has <perm> permissions
+#
+#   @param [Fixnum, String] permissions
+#     The permissions as octal number, e.g. `0700`, or String, e.g. `'0700'`
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if file has permissions
+#     true:
+#     * if file does not have permissions
+#
+#   @example Use matcher with octal number
+#
+#     RSpec.describe do
+#       it { expect(file).to have_permissions(0700) }
+#     end
+#
+#   @example Use matcher with string
+#
+#     RSpec.describe do
+#       it { expect(file).to have_permissions('0700') }
+#     end
+RSpec::Matchers.define :have_permissions do |expected|
+  expected_permissions = if expected.kind_of? Integer
+                           expected.to_s(8)
+                         else
+                           expected.gsub(/^0*/, '')
+                         end
+
+  match do |actual|
+    file_name = actual
+    actual_permissions = format( "%o", File::Stat.new(expand_path(file_name)).mode )[-4,4].gsub(/^0*/, '')
+
+    actual_permissions == expected_permissions
+  end
+
+  failure_message do |actual|
+    file_name = actual
+    actual_permissions = format( "%o", File::Stat.new(expand_path(file_name)).mode )[-4,4].gsub(/^0*/, '')
+
+    format("expected that file \"%s\" would have permissions \"%s\", but has \"%s\".", file_name, expected_permissions, actual_permissions)
+  end
+
+  failure_message_when_negated do |actual|
+    file_name = actual
+    actual_permissions = format( "%o", File::Stat.new(expand_path(file_name)).mode )[-4,4].gsub(/^0*/, '')
+
+    format("expected that file \"%s\" would not have permissions \"%s\", but has \"%s\".", file_name, expected_permissions, actual_permissions)
+  end
+end

data/lib/aruba/matchers/path.rb

@@ -0,0 +1,99 @@
+# @!method match_path_pattern(pattern)
+#   This matchers checks if <files>/directories match <pattern>
+#
+#   @param [String, Regexp] pattern
+#     The pattern to use.
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if there are no files/directories which match the pattern
+#     true:
+#     * if there are files/directories which match the pattern
+#
+#   @example Use matcher with regex
+#
+#     RSpec.describe do
+#       it { expect(Dir.glob(**/*)).to match_file_pattern(/.txt$/) }
+#     end
+#
+#   @example Use matcher with string
+#
+#     RSpec.describe do
+#       it { expect(Dir.glob(**/*)).to match_file_pattern('.txt$') }
+#     end
+RSpec::Matchers.define :match_path_pattern do |_|
+  match do |actual|
+    next  !actual.select { |a| a == expected }.empty? if expected.is_a? String
+
+    !actual.grep(expected).empty?
+  end
+
+  failure_message do |actual|
+    format("expected that path \"%s\" matches pattern \"%s\".", actual.join(", "), expected)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that path \"%s\" does not match pattern \"%s\".", actual.join(", "), expected)
+  end
+end
+
+# @!method be_existing_path
+#   This matchers checks if <path> exists in filesystem
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if path does not exist
+#     true:
+#     * if path exists
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(file).to be_existing_path }
+#       it { expect(directory).to be_existing_path }
+#     end
+RSpec::Matchers.define :be_existing_path do |_|
+  match do |actual|
+    exist?(actual)
+  end
+
+  failure_message do |actual|
+    format("expected that path \"%s\" exists", actual)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that path \"%s\" does not exist", actual)
+  end
+end
+
+# @!method be_absolute_path
+#   This matchers checks if <path> exists in filesystem
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if path is not absolute
+#     true:
+#     * if path is absolute
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(file).to be_absolute_path }
+#       it { expect(directory).to be_absolute_path }
+#     end
+RSpec::Matchers.define :be_absolute_path do |_|
+  match do |actual|
+    absolute?(actual)
+  end
+
+  failure_message do |actual|
+    format("expected that path \"%s\" is absolute, but it's not", actual)
+  end
+
+  failure_message_when_negated do |actual|
+    format("expected that path \"%s\" is not absolute, but it is", actual)
+  end
+end

data/lib/aruba/matchers/rspec_matcher_include_regexp.rb

@@ -1,5 +1,25 @@
+# @!method include_regexp(regexp)
+#   This matchers checks if items of an <array> matches regexp
+#
+#   @param [Regexp] regexp
+#     The regular expression to use
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if regexp does not match
+#     true:
+#     * if regexp matches
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(%w(asdf qwert)).to include_regexp(/asdf/) }
+#     end
 RSpec::Matchers.define :include_regexp do |expected|
   match do |actual|
-    ! actual.grep(expected).empty?
+    warn('The use of "include_regexp"-matchers is deprecated. It will be removed soon.')
+
+    !actual.grep(expected).empty?
   end
 end

data/lib/aruba/process_monitor.rb

@@ -0,0 +1,113 @@
+module Aruba
+  class ProcessMonitor
+    private
+
+    attr_reader :processes, :announcer
+
+    public
+
+    def initialize(announcer)
+      @processes = []
+      @announcer = announcer
+    end
+
+    def last_exit_status
+      return @last_exit_status if @last_exit_status
+      stop_processes!
+      @last_exit_status
+    end
+
+    def stop_process(process)
+      @last_exit_status = process.stop(announcer)
+    end
+
+    def terminate_process!(process)
+      process.terminate
+    end
+
+    def stop_processes!
+      processes.each do |_, process|
+        stop_process(process)
+      end
+    end
+
+    # Terminate all running processes
+    def terminate_processes
+      processes.each do |_, process|
+        terminate_process(process)
+        stop_process(process)
+      end
+    end
+
+    def register_process(name, process)
+      processes << [name, process]
+    end
+
+    def get_process(wanted)
+      matching_processes = processes.reverse.find{ |name, _| name == wanted }
+      raise ArgumentError.new("No process named '#{wanted}' has been started") unless matching_processes
+      matching_processes.last
+    end
+
+    def only_processes
+      processes.collect{ |_, process| process }
+    end
+
+    # Fetch output (stdout, stderr) from command
+    #
+    # @param [String] cmd
+    #   The command
+    def output_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      get_process(cmd).output
+    end
+
+    # Fetch stdout from command
+    #
+    # @param [String] cmd
+    #   The command
+    def stdout_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      get_process(cmd).stdout
+    end
+
+    # Fetch stderr from command
+    #
+    # @param [String] cmd
+    #   The command
+    def stderr_from(cmd)
+      cmd = Utils.detect_ruby(cmd)
+      get_process(cmd).stderr
+    end
+
+    # Get stdout of all processes
+    #
+    # @return [String]
+    #   The stdout of all process which have run before
+    def all_stdout
+      stop_processes!
+      only_processes.each_with_object("") { |ps, out| out << ps.stdout }
+    end
+
+    # Get stderr of all processes
+    #
+    # @return [String]
+    #   The stderr of all process which have run before
+    def all_stderr
+      stop_processes!
+      only_processes.each_with_object("") { |ps, out| out << ps.stderr }
+    end
+
+    # Get stderr and stdout of all processes
+    #
+    # @return [String]
+    #   The stderr and stdout of all process which have run before
+    def all_output
+      all_stdout << all_stderr
+    end
+
+    def clear
+      processes.clear
+    end
+  end
+end