aruba 0.7.4 → 0.8.0.pre

data/lib/aruba/api/command.rb

@@ -0,0 +1,351 @@
+require 'pathname'
+
+require 'aruba/platform'
+require 'aruba/process_monitor'
+require 'aruba/spawn_process'
+
+require 'win32/file' if File::ALT_SEPARATOR
+
+module Aruba
+  class << self
+    attr_accessor :process
+  end
+
+  self.process = Aruba::Processes::SpawnProcess
+end
+
+module Aruba
+  module Api
+    module Commands
+      # Resolve path for command using the PATH-environment variable
+      #
+      # @param [#to_s] program
+      #   The name of the program which should be resolved
+      #
+      # @param [String] path
+      #   The PATH, a string concatenated with ":", e.g. /usr/bin/:/bin on a
+      #   UNIX-system
+      def which(program, path = ENV['PATH'])
+        Aruba::Platform.which(program, path)
+      end
+
+      # Pipe data in file
+      #
+      # @param [String] file_name
+      #   The file which should be used to pipe in data
+      def pipe_in_file(file_name)
+        file_name = expand_path(file_name)
+
+        File.open(file_name, 'r').each_line do |line|
+          last_command.write(line)
+        end
+      end
+
+      # Fetch output (stdout, stderr) from command
+      #
+      # @param [String] cmd
+      #   The command
+      def output_from(cmd)
+        process_monitor.output_from(cmd)
+      end
+
+      # Fetch stdout from command
+      #
+      # @param [String] cmd
+      #   The command
+      def stdout_from(cmd)
+        process_monitor.stdout_from(cmd)
+      end
+
+      # Fetch stderr from command
+      #
+      # @param [String] cmd
+      #   The command
+      def stderr_from(cmd)
+        process_monitor.stderr_from(cmd)
+      end
+
+      # Get stdout of all processes
+      #
+      # @return [String]
+      #   The stdout of all process which have run before
+      def all_stdout
+        process_monitor.all_stdout
+      end
+
+      # Get stderr of all processes
+      #
+      # @return [String]
+      #   The stderr of all process which have run before
+      def all_stderr
+        process_monitor.all_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
+        process_monitor.all_output
+      end
+
+      # Full compare arg1 and arg2
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg1 is exactly the same as arg2 return true, otherwise false
+      def assert_exact_output(expected, actual)
+        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
+        expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).to eq Aruba::Platform.unescape(expected, aruba.config.keep_ansi)
+      end
+
+      # Partial compare arg1 and arg2
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg2 contains arg1 return true, otherwise false
+      def assert_partial_output(expected, actual)
+        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
+        expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).to include(Aruba::Platform.unescape(expected, aruba.config.keep_ansi))
+      end
+
+      # Regex Compare arg1 and arg2
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg2 matches arg1 return true, otherwise false
+      def assert_matching_output(expected, actual)
+        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
+        expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).to match(/#{Aruba::Platform.unescape(expected, aruba.config.keep_ansi)}/m)
+      end
+
+      # Negative regex compare arg1 and arg2
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg2 does not match arg1 return true, otherwise false
+      def assert_not_matching_output(expected, actual)
+        actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
+        expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).not_to match(/#{Aruba::Platform.unescape(expected, aruba.config.keep_ansi)}/m)
+      end
+
+      # Negative partial compare arg1 and arg2
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg2 does not match/include arg1 return true, otherwise false
+      def assert_no_partial_output(unexpected, actual)
+        actual.force_encoding(unexpected.encoding) if RUBY_VERSION >= "1.9"
+        if Regexp === unexpected
+          expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).not_to match unexpected
+        else
+          expect(Aruba::Platform.unescape(actual, aruba.config.keep_ansi)).not_to include(unexpected)
+        end
+      end
+
+      # Partial compare output of interactive command and arg1
+      #
+      # @return [TrueClass, FalseClass]
+      #   If output of interactive command includes arg1 return true, otherwise false
+      def assert_partial_output_interactive(expected)
+        Aruba::Platform.unescape(last_command.stdout, aruba.config.keep_ansi).include?(Aruba::Platform.unescape(expected, aruba.config.keep_ansi)) ? true : false
+      end
+
+      # Check if command succeeded and if arg1 is included in output
+      #
+      # @return [TrueClass, FalseClass]
+      #   If exit status is 0 and arg1 is included in output return true, otherwise false
+      def assert_passing_with(expected)
+        assert_success(true)
+        assert_partial_output(expected, all_output)
+      end
+
+      # Check if command failed and if arg1 is included in output
+      #
+      # @return [TrueClass, FalseClass]
+      #   If exit status is not equal 0 and arg1 is included in output return true, otherwise false
+      def assert_failing_with(expected)
+        assert_success(false)
+        assert_partial_output(expected, all_output)
+      end
+
+      # Check exit status of process
+      #
+      # @return [TrueClass, FalseClass]
+      #   If arg1 is true, return true if command was successful
+      #   If arg1 is false, return true if command failed
+      def assert_success(success)
+        if success
+          expect(last_command).to be_successfully_executed
+        else
+          expect(last_command).not_to be_successfully_executed
+        end
+      end
+
+      # @private
+      def assert_exit_status(status)
+        expect(last_command).to have_exit_status(status)
+      end
+
+      # @private
+      def assert_not_exit_status(status)
+        expect(last_exit_status).not_to eq(status),
+          append_output_to("Exit status was #{last_exit_status} which was not expected.")
+      end
+
+      # @private
+      def append_output_to(message)
+        "#{message} Output:\n\n#{all_output}\n"
+      end
+
+      def process_monitor
+        return @process_monitor if defined? @process_monitor
+
+        @process_monitor = ProcessMonitor.new(announcer)
+
+        @process_monitor
+      end
+
+      # @private
+      def processes
+        process_monitor.send(:processes)
+      end
+
+      # @private
+      def stop_processes!
+        process_monitor.stop_processes!
+      end
+
+      # Terminate all running processes
+      def terminate_processes!
+        process_monitor.terminate_processes!
+      end
+
+      # @private
+      def last_command
+        processes.last[1]
+      end
+
+      # @private
+      def register_process(*args)
+        process_monitor.register_process(*args)
+      end
+
+      # @private
+      def get_process(wanted)
+        process_monitor.get_process(wanted)
+      end
+
+      # Run given command and stop it if timeout is reached
+      #
+      # @param [String] cmd
+      #   The command which should be executed
+      #
+      # @param [Integer] timeout
+      #   If the timeout is reached the command will be killed
+      #
+      # @yield [SpawnProcess]
+      #   Run block with process
+      def run(cmd, timeout = nil)
+        timeout ||= exit_timeout
+        @commands ||= []
+        @commands << cmd
+
+        cmd = Aruba::Platform.detect_ruby(cmd)
+
+        announcer.announce(:directory, Dir.pwd)
+        announcer.announce(:command, cmd)
+        announcer.announce(:timeout, 'exit', aruba.config.exit_timeout)
+
+        process = Aruba.process.new(cmd, timeout, io_wait, expand_path('.'), aruba.environment.to_h)
+
+        if aruba.config.before? :cmd
+          # rubocop:disable Metrics/LineLength
+          Aruba::Platform.deprecated('The use of "before"-hook" ":cmd" is deprecated. Use ":command" instead. Please be aware that this hook gets the command passed in not the cmdline itself. To get the commandline use "#cmd.commandline"')
+          # rubocop:enable Metrics/LineLength
+          aruba.config.before(:cmd, self, cmd)
+        end
+
+        aruba.config.before(:command, self, process)
+
+        process_monitor.register_process(cmd, process)
+        process.run!
+
+        aruba.config.after(:command, self, process)
+
+        block_given? ? yield(process) : process
+      end
+
+      # Default exit timeout for running commands with aruba
+      #
+      # Overwrite this method if you want a different timeout or set
+      # `@aruba_timeout_seconds`.
+      def exit_timeout
+        aruba.config.exit_timeout
+      end
+
+      # Default io wait timeout
+      #
+      # Overwrite this method if you want a different timeout or set
+      # `@aruba_io_wait_seconds
+      def io_wait
+        aruba.config.io_wait_timeout
+      end
+
+      # The root directory of aruba
+      def root_directory
+        aruba.config.root_directory
+      end
+
+      # Run a command with aruba
+      #
+      # Checks for error during command execution and checks the output to detect
+      # an timeout error.
+      #
+      # @param [String] cmd
+      #   The command to be executed
+      #
+      # @param [TrueClass,FalseClass] fail_on_error
+      #   Should aruba fail on error?
+      #
+      # @param [Integer] timeout
+      #   Timeout for execution
+      def run_simple(cmd, fail_on_error = true, timeout = nil)
+        command = run(cmd, timeout)
+        @last_exit_status = command.stop(announcer)
+
+        @timed_out = command.timed_out?
+
+        if fail_on_error
+          expect(command).to have_finished_in_time
+          expect(command).to be_successfully_executed
+        end
+      end
+
+      # Provide data to command via stdin
+      #
+      # @param [String] input
+      #   The input for the command
+      def type(input)
+        return close_input if "" == input
+        last_command.write(input << "\n")
+      end
+
+      # Close stdin
+      def close_input
+        last_command.close_io(:stdin)
+      end
+
+      # TODO: move some more methods under here!
+
+      private
+
+      def last_exit_status
+        process_monitor.last_exit_status
+      end
+
+      def stop_process(process)
+        process_monitor.stop_process(process)
+      end
+
+      def terminate_process(process)
+        process_monitor.terminate_process(process)
+      end
+    end
+  end
+end

data/lib/aruba/api/core.rb

@@ -0,0 +1,141 @@
+require 'rspec/expectations'
+require 'aruba/announcer'
+require 'aruba/runtime'
+require 'aruba/errors'
+
+require 'aruba/config/jruby'
+
+module Aruba
+  module Api
+    module Core
+      include ::RSpec::Matchers
+
+      # Aruba Runtime
+      def aruba
+        @_aruba_runtime ||= Runtime.new
+      end
+
+      # Clean the working directory of aruba
+      #
+      # This will only clean up aruba's working directory to remove all
+      # artifacts of your tests. This does NOT clean up the current working
+      # directory.
+      def setup_aruba
+        Aruba::Platform.rm File.join(Aruba.config.root_directory, Aruba.config.working_directory), :force => true
+        Aruba::Platform.mkdir File.join(Aruba.config.root_directory, Aruba.config.working_directory)
+        Aruba::Platform.chdir Aruba.config.root_directory
+
+        self
+      end
+
+      # Switch to directory
+      #
+      # @param [String] dir
+      #   The directory
+      #
+      # @example Normal directory
+      #   cd 'dir'
+      #
+      # @example Move up
+      #   cd '..'
+      #
+      # @example Run code in directory
+      #   result = cd('some-dir') { Dir.getwd }
+      #
+      def cd(dir, &block)
+        fail ArgumentError, "#{expand_path(dir)} is not a directory or does not exist." unless directory?(dir)
+
+        if block_given?
+          cwd = (aruba.current_directory.dup << dir)
+          return Aruba::Platform.chdir(cwd, &block)
+        end
+
+        aruba.current_directory << dir
+
+        self
+      end
+
+      # Expand file name
+      #
+      # @param [String] file_name
+      #   Name of file
+      #
+      # @param [String] dir_string
+      #   Name of directory to use as starting point, otherwise current directory is used.
+      #
+      # @return [String]
+      #   The full path
+      #
+      # @example Single file name
+      #
+      #   # => <path>/tmp/aruba/file
+      #   expand_path('file')
+      #
+      # @example Single Dot
+      #
+      #   # => <path>/tmp/aruba
+      #   expand_path('.')
+      #
+      # @example using home directory
+      #
+      #   # => <path>/home/<name>/file
+      #   expand_path('~/file')
+      #
+      # @example using fixtures directory
+      #
+      #   # => <path>/test/fixtures/file
+      #   expand_path('%/file')
+      #
+      def expand_path(file_name, dir_string = nil)
+        # rubocop:disable Metrics/LineLength
+        message = %(Filename "#{file_name}" needs to be a string. It cannot be nil or empty either.  Please use `expand_path('.')` if you want the current directory to be expanded.)
+        # rubocop:enable Metrics/LineLength
+
+        fail ArgumentError, message unless file_name.is_a?(String) && !file_name.empty?
+
+        if RUBY_VERSION < '1.9'
+          prefix = file_name.chars.to_a[0]
+          rest = file_name.chars.to_a[1..-1].join('')
+        else
+          prefix = file_name[0]
+          rest = file_name[1..-1]
+        end
+
+        if aruba.config.fixtures_path_prefix == prefix
+          File.join aruba.fixtures_directory, rest
+        else
+          with_environment do
+            Aruba::Platform.chdir(aruba.current_directory) { Aruba::Platform.expand_path(file_name, dir_string) }
+          end
+        end
+      end
+
+      # Run block with environment
+      #
+      # @param [Hash] env (optional)
+      #   The variables to be used for block.
+      #
+      # @yield
+      #   The block of code which should be run with the modified environment variables
+      def with_environment(env = {}, &block)
+        if RUBY_VERSION <= '1.9.3'
+          old_env = ENV.to_hash
+        else
+          old_env = ENV.to_h
+        end
+
+        old_aruba_env = aruba.environment.to_h
+
+        ENV.update aruba.environment.update(env).to_h
+
+        block.call if block_given?
+      ensure
+        aruba.environment.clear
+        aruba.environment.update old_aruba_env
+
+        ENV.clear
+        ENV.update old_env
+      end
+    end
+  end
+end