sunshine 1.0.0.pre

data/test/mocks/mock_object.rb

@@ -0,0 +1,179 @@
+require 'cgi'
+
+module MockObject
+
+  ##
+  # Setup a method mock
+
+  def mock method, options={}, &block
+    mock_key = mock_key_for method, options
+    method_mocks[mock_key] = block_given? ? block : options[:return]
+  end
+
+
+  ##
+  # Get the value a mocked method was setup to return
+
+  def method_mock_return mock_key
+    return_val = method_mocks[mock_key] rescue method_mocks[[mock_key.first]]
+    if Proc === return_val
+      args = mock_key[1..-1]
+      return_val.call(*args)
+    else
+      return_val
+    end
+  end
+
+
+  ##
+  # Create a mock key based on :method, :args => [args_passed_to_method]
+
+  def mock_key_for method, options={}
+    mock_key = [method.to_s]
+    mock_key.concat [*options[:args]] if options.has_key?(:args)
+    mock_key
+  end
+
+
+  ##
+  # Check if a method was called. Supports options:
+  # :exactly:: num - exact number of times the method should have been called
+  # :count:: num   - minimum number of times the method should have been called
+  # Defaults to :count => 1
+
+  def method_called? method, options={}
+    target_count = options[:count] || options[:exactly] || 1
+
+    count = method_call_count method, options
+
+    options[:exactly] ? count == target_count : count >= target_count
+  end
+
+
+  ##
+  # Count the number of times a method was called:
+  #  obj.method_call_count :my_method, :args => [1,2,3]
+
+  def method_call_count method, options={}
+    count = 0
+
+    mock_def_arr = mock_key_for method, options
+
+    each_mock_key_matching(mock_def_arr) do |mock_key|
+      count = count + method_log[mock_key]
+    end
+
+    count
+  end
+
+
+  ##
+  # Do something with every instance of a mock key.
+  # Used to retrieve all lowest common denominators of method calls:
+  #
+  #   each_mock_key_matching [:my_method] do |mock_key|
+  #     puts mock_key.inspect
+  #   end
+  #
+  #   # Outputs #
+  #   [:my_method, 1, 2, 3]
+  #   [:my_method, 1, 2]
+  #   [:my_method, 1]
+  #   [:my_method]
+
+  def each_mock_key_matching mock_key
+    index = mock_key.length - 1
+
+    method_log.keys.each do |key|
+      yield(key) if block_given? && key[0..index] == mock_key
+    end
+  end
+
+
+  def method_mocks
+    @method_mocks ||= Hash.new do |h, k|
+      raise "Mock for #{k.inspect} does not exist."
+    end
+  end
+
+
+  def method_log
+    @method_log ||= Hash.new(0)
+  end
+
+
+  ##
+  # Hook into the object
+
+  def self.included base
+    hook_instance_methods base
+  end
+
+
+  def self.extended base
+    hook_instance_methods base, true
+  end
+
+
+  def self.hook_instance_methods base, instance=false
+    unhook_instance_methods base, instance
+
+    eval_each_method_of(base, instance) do |m|
+      m_def = m =~ /[^\]]=$/ ? "args" : "*args, &block"
+      new_m = escape_unholy_method_name "hooked_#{m}"
+      %{
+        alias #{new_m} #{m}
+        undef #{m}
+
+        def #{m}(#{m_def})
+          mock_key = mock_key_for '#{m}', :args => args
+
+          count = method_log[mock_key]
+          method_log[mock_key] = count.next
+          
+          method_mock_return(mock_key) rescue self.send(:#{new_m}, #{m_def})
+        end
+      }
+    end
+  end
+
+
+  def self.unhook_instance_methods base, instance=false
+    eval_each_method_of(base, instance) do |m|
+       new_m = escape_unholy_method_name "hooked_#{m}"
+       #puts m + " -> " + new_m
+      %{
+        m = '#{new_m}'.to_sym
+        defined = method_defined?(m) rescue self.class.method_defined?(m)
+
+        if defined
+          undef #{m}
+          alias #{m} #{new_m}
+        end
+      }
+    end
+  end
+
+
+  def self.escape_unholy_method_name name
+    CGI.escape(name).gsub('%','').gsub('-','MNS')
+  end
+
+
+  def self.eval_each_method_of base, instance=false, &block
+    eval_method, affect_methods = if instance
+      [:instance_eval, base.methods]
+    else
+      [:class_eval, base.instance_methods]
+    end
+
+    banned_methods = self.instance_methods
+    banned_methods.concat Object.instance_methods
+
+    affect_methods.sort.each do |m|
+      next if banned_methods.include?(m)
+      #puts m
+      base.send eval_method, block.call(m)
+    end
+  end
+end

data/test/mocks/mock_open4.rb

@@ -0,0 +1,117 @@
+module MockOpen4
+
+  LOGIN_CMD = "echo ready;"
+
+  CMD_RETURN = {
+    LOGIN_CMD => [:out, "ready\n"]
+  }
+
+  attr_reader :cmd_log
+
+  def popen4(*args)
+    cmd = args.join(" ")
+    @cmd_log ||= []
+    @cmd_log << cmd
+
+
+    pid = "test_pid"
+    inn_w = StringIO.new
+    out_r, out_w = IO.pipe
+    err_r, err_w = IO.pipe
+
+    ios = {:inn => inn_w, :out => out_w, :err => err_w}
+    stream, string = output_for cmd
+
+    ios[stream].write string
+    out_w.write nil
+    err_w.write nil
+
+    out_w.close
+    err_w.close
+
+    if block_given?
+      yield
+      inn_w.close
+      out_r.close
+      err_r.close
+    end
+
+    return pid, inn_w, out_r, err_r
+  end
+
+  def output_for(cmd)
+    @mock_output ||= {}
+    if @mock_output
+      output = @mock_output[cmd]
+      output ||= @mock_output[nil].shift if Array === @mock_output[nil]
+      @mock_output.delete(cmd)
+      if output
+        Process.set_exitcode output.delete(output.last)
+        return output
+      end
+    end
+
+    CMD_RETURN.each do |cmd_key, return_val|
+      return return_val if cmd.include? cmd_key
+    end
+    return :out, "some_value"
+  end
+
+  def set_mock_response code, stream_vals={}, options={}
+    @mock_output ||= {}
+    @mock_output[nil] ||= []
+    new_stream_vals = {}
+
+    stream_vals.each do |key, val|
+      if Symbol === key
+        @mock_output[nil] << [key, val, code]
+        next
+      end
+
+      key = ssh_cmd(key, options).join(" ") if Sunshine::RemoteShell === self
+
+      new_stream_vals[key] = (val.dup << code)
+    end
+    @mock_output.merge! new_stream_vals
+  end
+
+end
+
+
+class StatusStruct < Struct.new("Status", :exitstatus)
+  def success?
+    self.exitstatus == 0
+  end
+end
+
+
+Process.class_eval do
+  class << self
+
+    def set_exitcode(code)
+      @exit_code = code
+    end
+
+    alias old_waitpid2 waitpid2
+    undef waitpid2
+
+    def waitpid2(*args)
+      pid = args[0]
+      if pid == "test_pid"
+        exitcode = @exit_code ||= 0
+        @exit_code = 0
+        return [StatusStruct.new(exitcode)]
+      else
+        return old_waitpid2(*args)
+      end
+    end
+
+    alias old_kill kill
+    undef kill
+
+    def kill(type, pid)
+      return true if type == 0 && pid == "test_pid"
+      old_kill(type, pid)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,188 @@
+require 'sunshine'
+require 'test/unit'
+
+def no_mocks
+  ENV['mocks'] == "false"
+end
+
+unless no_mocks
+  require 'test/mocks/mock_object'
+  require 'test/mocks/mock_open4'
+end
+
+unless defined? TEST_APP_CONFIG_FILE
+  TEST_APP_CONFIG_FILE = "test/fixtures/app_configs/test_app.yml"
+end
+
+
+def mock_app
+  Sunshine::App.new(TEST_APP_CONFIG_FILE).extend MockObject
+end
+
+
+def mock_remote_shell host=nil
+  host ||= "user@some_server.com"
+  remote_shell = Sunshine::RemoteShell.new host
+
+  remote_shell.extend MockOpen4
+  remote_shell.extend MockObject
+
+  use_remote_shell remote_shell
+
+  remote_shell.connect
+  remote_shell
+end
+
+
+def mock_svn_response url=nil
+  url ||= "svn://subversion/path/to/my_app/trunk"
+
+  svn_response = <<-STR
+    <?xml version="1.0"?>
+    <log>
+    <logentry
+      revision="777">
+    <author>user</author>
+    <date>2010-01-26T01:49:17.372152Z</date>
+    <msg>finished testing server.rb</msg>
+    </logentry>
+    </log>
+  STR
+
+  Sunshine::SvnRepo.extend(MockObject) unless
+    Sunshine::SvnRepo.is_a?(MockObject)
+
+  Sunshine::SvnRepo.mock :svn_log, :return => svn_response
+  Sunshine::SvnRepo.mock :get_svn_url, :return => url
+end
+
+
+def mock_remote_shell_popen4
+  return if no_mocks
+  Sunshine::RemoteShell.class_eval{ include MockOpen4 }
+end
+
+
+def set_mock_response_for obj, code, stream_vals={}, options={}
+  case obj
+  when Sunshine::App then
+    obj.each do |sa|
+      sa.shell.set_mock_response code, stream_vals, options
+    end
+  when Sunshine::ServerApp then
+    obj.shell.set_mock_response code, stream_vals, options
+  when Sunshine::RemoteShell then
+    obj.set_mock_response code, stream_vals, options
+  end
+end
+
+
+def assert_dep_install dep_name, type=Sunshine::Yum
+  prefered = type rescue nil
+  args = [{:call => @remote_shell, :prefer => prefered}]
+
+  dep = if Sunshine::Dependency === dep_name
+          dep_name
+        else
+          Sunshine.dependencies.get(dep_name, :prefer => prefered)
+        end
+
+
+  assert dep.method_called?(:install!, :args => args),
+    "Dependency '#{dep_name}' install was not called."
+end
+
+
+def assert_not_called *args
+  assert !@remote_shell.method_called?(:call, :args => [*args]),
+    "Command called by #{@remote_shell.host} but should't have:\n #{args[0]}"
+end
+
+
+def assert_server_call *args
+  assert @remote_shell.method_called?(:call, :args => [*args]),
+    "Command was not called by #{@remote_shell.host}:\n #{args[0]}"
+end
+
+
+def assert_bash_script name, cmds, check_value
+  cmds = cmds.map{|cmd| "(#{cmd})" }
+  cmds << "echo true"
+
+  bash = <<-STR
+#!/bin/bash
+if [ "$1" == "--no-env" ]; then
+  #{cmds.flatten.join(" && ")}
+else
+  #{@app.root_path}/env #{@app.root_path}/#{name} --no-env
+fi
+  STR
+
+  assert_equal bash, check_value
+end
+
+
+def assert_ssh_call expected, ds=@remote_shell, options={}
+  expected = ds.send(:ssh_cmd, expected, options).join(" ")
+
+  error_msg = "No such command in remote_shell log [#{ds.host}]\n#{expected}"
+  error_msg << "\n\n#{ds.cmd_log.select{|c| c =~ /^ssh/}.join("\n\n")}"
+
+  assert ds.cmd_log.include?(expected), error_msg
+end
+
+
+def assert_rsync from, to, ds=@remote_shell, sudo=false
+  received = ds.cmd_log.last
+
+  rsync_path = if sudo
+    path = ds.sudo_cmd('rsync', sudo).join(' ')
+    "--rsync-path='#{ path }' "
+  end
+
+  rsync_cmd = "rsync -azP #{rsync_path}-e \"ssh #{ds.ssh_flags.join(' ')}\""
+
+  error_msg = "No such command in remote_shell log [#{ds.host}]\n#{rsync_cmd}"
+  error_msg << "#{from.inspect} #{to.inspect}"
+  error_msg << "\n\n#{ds.cmd_log.select{|c| c =~ /^rsync/}.join("\n\n")}"
+
+  if Regexp === from
+    found = ds.cmd_log.select do |cmd|
+
+      cmd_from = cmd.split(" ")[-2]
+      cmd_to   = cmd.split(" ").last
+
+      cmd_from =~ from && cmd_to == to && cmd.index(rsync_cmd) == 0
+    end
+
+    assert !found.empty?, error_msg
+  else
+    expected = "#{rsync_cmd} #{from} #{to}"
+    assert ds.cmd_log.include?(expected), error_msg
+  end
+end
+
+
+def use_remote_shell remote_shell
+  @remote_shell = remote_shell
+end
+
+
+def each_remote_shell app=@app
+  app.server_apps.each do |sa|
+    use_remote_shell sa.shell
+    yield(sa.shell) if block_given?
+  end
+end
+
+Sunshine.setup({}, true)
+
+unless MockObject === Sunshine.shell
+  Sunshine.shell.extend MockObject
+  Sunshine.shell.mock :<<, :return => nil
+  Sunshine.shell.mock :write, :return => nil
+end
+
+unless Sunshine::Dependency.include? MockObject
+  Sunshine::Dependency.send(:include, MockObject)
+end