right_agent 0.5.1

data/spec/idempotent_request_spec.rb

@@ -0,0 +1,136 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe RightScale::IdempotentRequest do
+
+  module RightScale
+    class SenderMock
+      include Singleton
+    end
+  end
+
+  before(:all) do
+    if @sender_exists = RightScale.const_defined?(:Sender)
+      RightScale.module_eval('OldSender = Sender')
+    end
+    RightScale.module_eval('Sender = SenderMock')
+  end
+
+  after(:all) do
+    if @sender_exists
+      RightScale.module_eval('Sender = OldSender')
+    end
+  end
+
+  context ':targets option' do
+    context 'when :targets=>nil' do
+      it 'should send target-less requests' do
+        request = RightScale::IdempotentRequest.new('type', 'payload')
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+            and_yield(RightScale::OperationResult.non_delivery('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        request.run
+      end
+    end
+
+    context 'when one target is specified' do
+      it 'should send a targeted request' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :targets=>[1])
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', 1, Proc).
+            and_yield(RightScale::OperationResult.non_delivery('test')).once
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        request.run
+      end
+    end
+
+    context 'when many targets are specified' do
+      it 'should choose a random target' do
+        request = RightScale::IdempotentRequest.new('type', 'payload', :targets=>[1, 2, 3])
+        flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |type, payload, tgt, block|
+          type.should == 'type'
+          payload.should == 'payload'
+          [1,2,3].should include(tgt)
+          block.call(RightScale::OperationResult.non_delivery('test'))
+        end
+        flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+        request.run
+      end
+    end
+  end
+
+  it 'should retry non-delivery responses' do
+    request = RightScale::IdempotentRequest.new('type', 'payload')
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        and_yield(RightScale::OperationResult.non_delivery('test')).once
+    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+    request.run
+  end
+
+  it 'should retry retry responses' do
+    request = RightScale::IdempotentRequest.new('type', 'payload')
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        and_yield(RightScale::OperationResult.retry('test')).once
+    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+    request.run
+  end
+
+  it 'should fail in case of error responses by default' do
+    request = RightScale::IdempotentRequest.new('type', 'payload')
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        and_yield(RightScale::OperationResult.error('test')).once
+    flexmock(request).should_receive(:fail).once
+    request.run
+  end
+
+  it 'should retry error responses when told to' do
+    request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        and_yield(RightScale::OperationResult.error('test')).once
+    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).once
+    request.run
+  end
+
+  it 'should ignore responses that arrive post-cancel' do
+    request = RightScale::IdempotentRequest.new('type', 'payload')
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).with('type', 'payload', nil, Proc).
+        and_yield(RightScale::OperationResult.success('test')).once
+    flexmock(request).should_receive(:fail).once
+    flexmock(request).should_receive(:succeed).never
+    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, Proc).never
+    request.cancel('test')
+    request.run
+  end
+
+  it 'should ignore duplicate responses' do
+    request = RightScale::IdempotentRequest.new('type', 'payload', :retry_on_error => true)
+    flexmock(RightScale::Sender.instance).should_receive(:send_retryable_request).and_return do |t, p, tgt, b|
+      5.times { b.call(RightScale::OperationResult.success('test')) }
+    end
+    flexmock(request).should_receive(:fail).never
+    flexmock(request).should_receive(:succeed).once
+    flexmock(EM).should_receive(:add_timer).with(RightScale::IdempotentRequest::DEFAULT_RETRY_DELAY, nil, Proc).never
+    request.run
+  end
+
+end

data/spec/log_spec.rb

@@ -0,0 +1,177 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe RightScale::Log do
+
+  # Count number of lines logged with the specified text
+  # Search is case sensitive and regular expression sensitive
+  #
+  # === Parameters
+  # text(String):: Text to search for
+  #
+  # === Return
+  # (Integer):: Number of lines where text found
+  def log_count(text)
+    # no such animal as egrep in windows, so hacked up an equivalent here.
+    pattern = Regexp.compile(text)
+    File.read(@log_file).each.select { |x| x =~ pattern }.count
+  end
+
+  before(:all) do
+    ENV['RS_LOG'] = 'true'
+  end
+
+  before(:each) do
+    Singleton.__init__(RightScale::Log)
+  end
+
+  after(:all) do
+    Singleton.__init__(RightScale::Log)
+    ENV['RS_LOG'] = nil
+  end
+
+  it 'should set default level to info' do
+    RightScale::Log.level.should == :info
+  end
+
+  it 'should change level to debug when force_debug' do
+    RightScale::Log.level.should == :info
+    RightScale::Log.force_debug
+    RightScale::Log.level.should == :debug
+  end
+
+  it 'should notify of log level change' do
+    RightScale::Log.level.should == :info
+    notified = nil
+    RightScale::Log.notify(lambda{ |l| notified = l })
+    RightScale::Log.level = :debug
+    notified.should == Logger::DEBUG
+  end
+
+  context "logging" do
+
+    before(:each) do
+      # note that log directory doesn't necessarily exist in Windows dev/test
+      # environment.
+      log_dir = RightScale::Platform.filesystem.log_dir
+      FileUtils.mkdir_p(log_dir) unless File.directory?(log_dir)
+
+      # use a unique name for the test because the file cannot be deleted after
+      # the test in the Windows case (until the process exits) and we need to
+      # avoid any potential conflicts with other tests, etc.
+      @log_name = "log_test-9D9A9CB7-24A1-4093-9F75-D462D373A0D8"
+      @log_file = File.join(log_dir, "#{@log_name}.log")
+      RightScale::Log.program_name = "tester"
+      RightScale::Log.log_to_file_only(true)
+      RightScale::Log.init(@log_name, log_dir)
+    end
+
+    after(:each) do
+      # note that the log is held open in the Windows case by Log so we
+      # cannot delete it after each test. on the other hand, we can truncate the
+      # log to zero size and continue to the next test (ultimately leaving an
+      # empty file after the test, which is acceptable).
+      File.delete(@log_file) if File.file?(@log_file) rescue File.truncate(@log_file, 0)
+    end
+
+    it 'should log info but not debug by default' do
+      RightScale::Log.debug("Test debug")
+      RightScale::Log.info("Test info")
+      log_count("Test debug$").should == 0
+      log_count("Test info$").should == 1
+    end
+
+    it 'should log debug after adjust level to :debug' do
+      RightScale::Log.level = :debug
+      RightScale::Log.debug("Test debug")
+      RightScale::Log.info("Test info")
+      log_count("Test debug$").should == 1
+      log_count("Test info$").should == 1
+    end
+
+    it 'should log additional error string when given' do
+      RightScale::Log.warning("Test warning", "Error")
+      RightScale::Log.error("Test error", "Error")
+      log_count("Test warning \\\(Error\\\)$").should == 1
+      log_count("Test error \\\(Error\\\)$").should == 1
+    end
+
+    it 'should log without exception when none given' do
+      begin
+        nil + "string"
+      rescue Exception => e
+        RightScale::Log.warning("Test warning")
+        RightScale::Log.error("Test error")
+      end
+      log_count("Test warning$").should == 1
+      log_count("Test error$").should == 1
+    end
+
+    it 'should log with exception class, message, and caller appended by default when exception given' do
+      begin
+        nil + "string"
+      rescue Exception => e
+        RightScale::Log.warning("Test warning", e)
+        RightScale::Log.error("Test error", e)
+      end
+      log_count("Test warning \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in .*log_spec.*\\\)$").should == 1
+      log_count("Test error \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in .*log_spec.*\\\)$").should == 1
+    end
+
+    it 'should log with exception class, message, and caller appended when use :caller' do
+      begin
+        nil + "string"
+      rescue Exception => e
+        RightScale::Log.warning("Test warning", e, :caller)
+        RightScale::Log.error("Test error", e, :caller)
+      end
+      log_count("Test warning \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in .*log_spec.*\\\)$").should == 1
+      log_count("Test error \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in .*log_spec.*\\\)$").should == 1
+    end
+
+    it 'should log with exception class and message appended when use :no_trace' do
+      begin
+        nil + "string"
+      rescue Exception => e
+        RightScale::Log.warning("Test warning", e, :no_trace)
+        RightScale::Log.error("Test error", e, :no_trace)
+      end
+      log_count("Test warning \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass\\\)$").should == 1
+      log_count("Test error \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass\\\)$").should == 1
+    end
+
+    it 'should log with exception class, message, and full backtrace appended when use :trace' do
+      begin
+        nil + "string"
+      rescue Exception => e
+        RightScale::Log.warning("Test warning", e, :trace)
+        RightScale::Log.error("Test error", e, :trace)
+      end
+      log_count("Test warning \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in$").should == 1
+      log_count("Test error \\\(NoMethodError: undefined method \\\`\\\+\' for nil:NilClass in$").should == 1
+    end
+
+  end
+
+end

data/spec/monkey_patches/amqp_patch_spec.rb

@@ -0,0 +1,100 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'right_agent', 'monkey_patches', 'amqp_patch'))
+
+describe AMQP::Client do
+  context 'with an incorrect AMQP password' do
+    class SUT
+      include AMQP::Client
+
+      attr_accessor :reconnecting, :settings, :channels
+    end
+
+    before(:each) do
+      @sut = flexmock(SUT.new)
+      @sut.reconnecting = false
+      @sut.settings = {:host => 'testhost', :port=>'12345'}
+      @sut.channels = {}
+
+      @sut.should_receive(:initialize)
+    end
+
+    context 'and no :reconnect_delay' do
+      it 'should reconnect immediately' do
+        flexmock(EM).should_receive(:reconnect).once
+        flexmock(EM).should_receive(:add_timer).never
+
+        @sut.reconnect()
+      end
+    end
+
+    context 'and a :reconnect_delay of true' do
+      it 'should reconnect immediately' do
+        @sut.settings[:reconnect_delay] = true
+
+        flexmock(EM).should_receive(:reconnect).once
+        flexmock(EM).should_receive(:add_timer).never
+
+        @sut.reconnect()
+      end
+    end
+
+    context 'and a :reconnect_delay of 15 seconds' do
+      it 'should schedule a reconnect attempt in 15s' do
+        @sut.settings[:reconnect_delay] = 15
+
+        flexmock(EM).should_receive(:reconnect).never
+        flexmock(EM).should_receive(:add_timer).with(15, Proc).once
+
+        @sut.reconnect()
+      end
+    end
+
+    context 'and a :reconnect_delay containing a Proc that returns 30' do
+      it 'should schedule a reconnect attempt in 30s' do
+        @sut.settings[:reconnect_delay] = Proc.new {30}
+
+        flexmock(EM).should_receive(:reconnect).never
+        flexmock(EM).should_receive(:add_timer).with(30, Proc).once
+
+        @sut.reconnect()
+      end
+    end
+
+    context 'and a :reconnect_interval of 5 seconds'  do
+      it 'should schedule reconnect attempts on a 5s interval' do
+        @sut.reconnecting = true
+        @sut.settings[:reconnect_delay] = 15
+        @sut.settings[:reconnect_interval] = 5
+
+        flexmock(EM).should_receive(:reconnect).never
+        flexmock(EM).should_receive(:add_timer).with(5, Proc).once
+
+        @sut.reconnect()
+      end
+    end
+
+  end
+
+end

data/spec/monkey_patches/eventmachine_spec.rb

@@ -0,0 +1,62 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe EventMachine do
+
+  it "should not repeatedly run deferred task if task raises an exception" do
+    error = nil
+    count = 0
+    EM.error_handler { |e| error = e; raise e if (count += 1) > 1 }
+
+    begin
+      EM.run do
+        EM.add_timer(1) { EM.next_tick { EM.stop } }
+        EM.next_tick { raise 'test' }
+      end
+    rescue Exception => error
+      error.should == nil
+    end
+
+    EM.error_handler(nil)
+
+    error.class.should == RuntimeError
+    error.message.should == 'test'
+    count.should == 1
+  end
+
+  it "should end EM loop if deferred task raises an exception and there is no error handler" do
+    count = 0
+    begin
+      EM.run do
+        EM.add_timer(0) { raise 'test' }
+      end
+    rescue Exception => error
+      error.class.should == RuntimeError
+      error.message.should == 'test'
+      count += 1
+    end
+    count.should == 1
+  end
+
+end