right_support 2.6.17 → 2.7.0

data/spec/log/system_logger_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+# NOTE: this spec does not get defined or executed unless SystemLogger
+# is defined, which only happens if Ruby standard-library 'syslog' module is
+# available at runtime. Thus, the spec does not run on Windows.
+#
+# The selective execution is accomplished with a trailing 'if' for this
+# outermost describe block. Crude but effective. You have been warned!
+describe 'RightSupport::Log::SystemLogger' do
+  subject { RightSupport::Log::SystemLogger }
+
+  # Duplicate constants for easier reading
+  SEVERITY_MAP = RightSupport::Log::SystemLogger::SEVERITY_MAP
+  FACILITY_MAP = RightSupport::Log::SystemLogger::FACILITY_MAP
+
+  before(:each) do
+    @mock_syslog = flexmock(Syslog)
+    #indicates we sent a bogus severity to syslog!
+    @mock_syslog.should_receive(SEVERITY_MAP[Logger::UNKNOWN]).never
+    flexmock(Syslog).should_receive(:open).and_return(@mock_syslog).by_default
+  end
+
+  after(:each) do
+    subject.instance_eval { class_variable_set(:@@syslog, nil) }
+  end
+
+  context :initialize do
+    context 'with :facility option' do
+      FACILITY_MAP.each_pair do |name, const|
+        it "should handle #{name}" do
+          @mock_syslog.should_receive(:open).with('unit tests', nil, const)
+          subject.new('unit tests', :facility=>name)
+        end
+      end
+    end
+  end
+
+  context :add do
+    context 'severity levels' do
+      levels = { :debug=>:debug,
+                 :info=>:info, :warn=>:notice,
+                 :error=>:warning, :fatal=>:err }
+
+      levels.each_pair do |logger_method, syslog_method|
+        it "translates Logger##{logger_method} to Syslog##{syslog_method}" do
+          @logger = subject.new('spec')
+          @mock_syslog.should_receive(syslog_method).with('moo bah oink')
+          @logger.__send__(logger_method, 'moo bah oink')
+        end
+      end
+    end
+
+    it 'escapes % characters to avoid confusing printf()' do
+      @logger = subject.new('spec')
+      flexmock(@logger).should_receive(:emit_syslog).with(Integer, 'All systems 100%% -- %%licious!')
+
+      @logger.info('All systems 100% -- %licious!')
+    end
+
+    context 'given :split option' do
+      it 'when true, splits multi-line messages' do
+        @logger = subject.new('spec', :split=>true)
+        flexmock(@logger).should_receive(:emit_syslog).times(5)
+
+        @logger.info("This is a\nmulti line\r\nlog message\n\rwith all kinds\n\n\rof stuff")
+      end
+
+      it 'when false, passes through multi-line messages' do
+        @logger = subject.new('spec', :split=>false)
+        flexmock(@logger).should_receive(:emit_syslog).times(1)
+
+        @logger.info("This is a\nmulti line\r\nlog message\n\rwith all kinds\n\n\rof stuff")
+      end
+    end
+
+    context 'given :color option' do
+      it 'when true, passes through ANSI color codes' do
+        @logger = subject.new('spec', :color=>true)
+        flexmock(@logger).should_receive(:emit_syslog).with(Integer, /[\e]/)
+
+        @logger.info("This has \e[16;32mcolor\e[7;0m inside it!")
+      end
+
+      it 'when false, strips out ANSI color codes' do
+        @logger = subject.new('spec', :color=>false)
+        flexmock(@logger).should_receive(:emit_syslog).with(Integer, /[^\e]/)
+
+        @logger.info("This has \e[16;32mcolor\e[7;0m inside it!")
+      end
+    end
+  end
+end if defined?(RightSupport::Log::SystemLogger)

data/spec/net/address_helper_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe RightSupport::Net::AddressHelper do
+  class AddressHelperTarget
+    include RightSupport::Net::AddressHelper
+  end
+
+  before(:each) do
+    @helper = AddressHelperTarget.new
+  end
+
+  describe :my_ipv4_addresses do
+
+  end
+
+  describe :my_ipv4_address do
+    it 'consistently chooses the lowest-numbered address' do
+      p = ['10.0.1.17', '192.168.7.5', '192.168.4.2', '127.0.0.1']
+      flexmock(@helper).should_receive(:local_routable_address).with(Socket::AF_INET).and_return(p[0])
+      flexmock(@helper).should_receive(:local_hostname_addresses).with(Socket::AF_INET).once.ordered.and_return([ p[3], p[2] ])
+      flexmock(@helper).should_receive(:local_hostname_addresses).with(Socket::AF_INET).once.ordered.and_return([ p[1], p[2] ])
+
+      one = @helper.my_ipv4_address(:private)
+      two = @helper.my_ipv4_address(:private)
+      one.should == p[0]
+      two.should == p[0]
+    end
+  end
+
+  describe :my_ipv4_addresses do
+    before(:each) do
+      routable_addr  = '67.2.204.5'
+      hostname_addrs = ['127.0.0.1', '10.0.0.15', '67.2.204.5']
+      flexmock(@helper).should_receive(:local_routable_address).with(Socket::AF_INET).and_return(routable_addr)
+      flexmock(@helper).should_receive(:local_hostname_addresses).with(Socket::AF_INET).and_return(hostname_addrs)
+      flexmock(@helper).should_receive(:local_hostname_addresses).with(Socket::AF_INET).and_return(hostname_addrs)
+    end
+
+    context 'with :loopback option' do
+      it 'returns only loopback addresses' do
+        @helper.my_ipv4_addresses(:loopback).should == ['127.0.0.1']
+      end
+    end
+
+    context 'with :private option' do
+      it 'returns only private addresses' do
+        @helper.my_ipv4_addresses(:private).should == ['10.0.0.15']
+      end
+    end
+
+    context 'with :public option' do
+      it 'returns only public addresses' do
+        @helper.my_ipv4_addresses(:public).should == ['67.2.204.5']
+      end
+    end
+  end
+end

data/spec/net/balancing/health_check_spec.rb

@@ -0,0 +1,382 @@
+require 'spec_helper'
+
+describe RightSupport::Net::LB::HealthCheck do
+  context :initialize do
+
+  end
+
+  before(:each) do
+    @endpoints = [1,2,3,4,5]
+    @yellow_states = 4
+    @reset_time = 60
+    @policy = RightSupport::Net::LB::HealthCheck.new(
+                :yellow_states => @yellow_states,
+                :reset_time => @reset_time)
+    @policy.set_endpoints(@endpoints)
+    @trials = 2500
+  end
+
+  context :initialize do
+    it 'starts endpoints in yellow-1 state' do
+      stats = @policy.get_stats
+      @endpoints.each { |ep| stats[ep].should == 'yellow-1' }
+    end
+  end
+
+  context :good do
+    context 'given a red server' do
+      before(:each) do
+        @red = @endpoints.first
+        @yellow_states.times { @policy.bad(@red, 0, Time.now) }
+        @policy.should have_red_endpoint(@red)
+      end
+
+      it "changes to yellow-N" do
+        @policy.good(@red, 0, Time.now)
+        @policy.should have_yellow_endpoint(@red, @yellow_states-1)
+      end
+    end
+
+    context 'given a yellow-N server' do
+      before(:each) do
+        @yellow = @endpoints.first
+        (@yellow_states-1).times { @policy.bad(@yellow, 0, Time.now) }
+        @policy.should have_yellow_endpoint(@yellow, @yellow_states)
+      end
+
+      it 'decreases the yellow level to N-1' do
+        @policy.good(@yellow, 0, Time.now)
+        @policy.should have_yellow_endpoint(@yellow, @yellow_states-1)
+      end
+
+      context 'when N == 1' do
+        before(:each) do
+          @yellow = @endpoints[1] #this should be yellow-1 since we haven't tampered with it yet
+          @policy.get_stats[@yellow].should == 'yellow-1'
+        end
+
+        it 'changes to green' do
+          @policy.should have_yellow_endpoint(@yellow, 1)
+          @policy.good(@yellow, 0, Time.now)
+          @policy.should have_green_endpoint(@yellow)
+        end
+      end
+    end
+
+    context 'when on_health_change callback is enabled' do
+      before(:each) do
+        @yellow_states = 3
+        @health_updates = []
+        @policy = RightSupport::Net::LB::HealthCheck.new({
+                    :yellow_states => @yellow_states, :reset_time => @reset_time,
+                    :on_health_change => lambda { |health| @health_updates << health }})
+        @policy.set_endpoints(@endpoints)
+
+        # put everyone into green state, then forget all health updates. this helps us write an
+        # easier test.
+        @endpoints.each { |ep| @policy.good(ep, 0, Time.now) }
+        @health_updates = []
+      end
+
+      it "notifies of overall improving health only at transition points" do
+        endpoints = @endpoints.shuffle
+        endpoints.shuffle.each { |ep| @policy.bad(ep, 0, Time.now) }
+        endpoints.shuffle.each { |ep| @policy.bad(ep, 0, Time.now) }
+        endpoints.shuffle.each { |ep| @policy.bad(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red']
+        @policy.good(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2']
+        endpoints[1..-1].each { |ep| @policy.good(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2']
+        @policy.good(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1']
+        @policy.bad(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1', 'yellow-2']
+        @policy.good(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1', 'yellow-2', 'yellow-1']
+        2.times { @policy.good(endpoints[1], 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1', 'yellow-2', 'yellow-1', 'green']
+        endpoints.each { |ep| @policy.good(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1', 'yellow-2', 'yellow-1', 'green']
+        endpoints.each { |ep| @policy.good(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red', 'yellow-2', 'yellow-1', 'yellow-2', 'yellow-1', 'green']
+      end
+    end
+  end
+
+  context :bad do
+    context 'given a green server' do
+      before(:each) do
+        @green = @endpoints.first
+        @policy.good(@green, 0, Time.now)
+        @policy.should have_green_endpoint(@green)
+      end
+
+      it 'changes to yellow-1' do
+        @policy.bad(@green, 0, Time.now)
+        @policy.should have_yellow_endpoint(@green, 1)
+      end
+    end
+
+    context 'given a yellow-N server' do
+      before(:each) do
+        @yellow = @endpoints.first
+      end
+
+      it 'increases the yellow level to N+1' do
+        @policy.bad(@yellow, 0, Time.now)
+        @policy.should have_yellow_endpoint(@yellow, 2)
+      end
+
+      context 'when N == yellow_states-1' do
+        before(:each) do
+          n = @yellow_states - 2
+          n.times { @policy.bad(@yellow, 0, Time.now) }
+          @policy.should have_yellow_endpoint(@yellow, n+1)
+        end
+
+        it 'changes to red' do
+          @policy.bad(@yellow, 0, Time.now)
+          @policy.should have_red_endpoint(@yellow)
+        end
+      end
+    end
+
+    context 'given a red server' do
+      it 'does nothing' do
+        @red = @endpoints.first
+        @yellow_states.times { @policy.bad(@red, 0, Time.now) }
+        @policy.should have_red_endpoint(@red)
+
+        @policy.bad(@red, 0, Time.now)
+        @policy.should have_red_endpoint(@red)
+      end
+    end
+
+    context 'when on_health_change callback is enabled' do
+      before(:each) do
+        @yellow_states = 3
+        @health_updates = []
+        @policy = RightSupport::Net::LB::HealthCheck.new({
+                    :yellow_states => @yellow_states, :reset_time => @reset_time,
+                    :on_health_change => lambda { |health| @health_updates << health }})
+        @policy.set_endpoints(@endpoints)
+
+        # put everyone into green state, then forget all health updates. this helps us write an
+        # easier test.
+        @endpoints.each { |ep| @policy.good(ep, 0, Time.now) }
+        @health_updates = []
+      end
+
+      it "notifies of overall worsening health only at transition points" do
+        # make most endpoints yellow-1
+        endpoints = @endpoints.shuffle
+        endpoints[1..-1].each { |ep| @policy.bad(ep, 0, Time.now) }
+        @policy.bad(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1']
+        endpoints.each { |ep| @policy.bad(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2']
+        endpoints[1..-1].each { |ep| @policy.bad(ep, 0, Time.now) }
+        @health_updates.should == ['yellow-1', 'yellow-2']
+        @policy.bad(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red']
+        @policy.bad(endpoints[0], 0, Time.now)
+        @health_updates.should == ['yellow-1', 'yellow-2', 'red']
+      end
+    end
+  end
+
+  context :next do
+
+    context 'given all green servers' do
+      it 'chooses fairly' do
+        test_random_distribution do 
+          @policy.next
+        end
+      end
+    end
+
+    context 'given all red servers' do
+      it 'returns nil to indicate no servers are available' do
+        @endpoints.each do |endpoint|
+          @yellow_states.times { @policy.bad(endpoint, 0, Time.now) }
+          @policy.should have_red_endpoint(endpoint)
+        end
+        @policy.next.should be_nil
+      end
+    end
+
+    context 'given a mixture of servers' do
+      it 'never chooses red servers' do
+        @red = @endpoints.first
+        @yellow_states.times { @policy.bad(@red, 0, Time.now) }
+        @policy.should have_red_endpoint(@red)
+
+        seen = find_empirical_distribution(@trials,@endpoints) do 
+          @policy.next
+        end
+
+        seen.include?(@red).should be_false
+      end
+
+      it 'chooses fairly from the green and yellow servers' do
+        @red = @endpoints.first
+        @yellow_states.times { @policy.bad(@red, 0, Time.now) }
+        @policy.should have_red_endpoint(@red)
+
+        seen = find_empirical_distribution(@trials,@endpoints) do
+          @policy.next
+        end
+
+        seen.include?(@red).should be_false
+        should_be_chosen_fairly(seen, @trials, @endpoints.size - 1)
+      end
+
+      it 'demands a health check for yellow servers' do
+        pending
+      end
+
+      it "maintains the same order of green and yellow servers" do
+        actual = []
+        expected = [3,4,1,2]
+
+        endpoints = [1,2,3,4]
+        policy = RightSupport::Net::LB::HealthCheck.new(:yellow_states => 1)
+        policy.set_endpoints(endpoints)
+        policy.instance_variable_set(:@counter, 1)
+        endpoints.size.times do
+          endpoint, yellow = policy.next
+          policy.bad(endpoint, 0, Time.now) unless endpoint == 4
+          actual << endpoint
+        end
+
+        actual.should == expected
+      end
+    end
+
+    context 'given a red server' do
+      before(:each) do
+        @red = @endpoints.first
+        (@yellow_states-1).times { @policy.bad(@red, 0, Time.now - 60) }
+      end
+
+      context 'when @reset_time passes' do
+        it 'resets the server to yellow' do
+          @policy.should have_red_endpoint(@red)
+          @policy.next
+          @policy.should have_yellow_endpoint(@red, @yellow_states-1)
+        end
+      end
+
+    end
+
+    context 'given a yellow-2 server' do
+      before(:each) do
+        @yellow = @endpoints.first
+        @policy.bad(@yellow, 0, Time.now - 60)
+        @policy.should have_yellow_endpoint(@yellow, 2)
+      end
+
+      context 'when @reset_time passes' do
+        it 'decreases the yellow level to N-1' do
+          @policy.next
+          @policy.should have_yellow_endpoint(@yellow, 1)
+        end
+      end
+    end
+
+    context 'given a yellow-1 server' do
+      before(:each) do
+        @yellow = @endpoints.first
+        @policy.good(@yellow, 0, Time.now - 60)
+        @policy.bad(@yellow, 0, Time.now - 60)
+        @policy.should have_yellow_endpoint(@yellow, 1)
+      end
+
+      context 'when @reset_time passes' do
+        it 'resets the server to green' do
+          @policy.next
+          @policy.should have_green_endpoint(@yellow)
+        end
+      end
+    end
+  end
+
+  context :get_stats do
+    context 'given all green servers' do
+      before(:each) do
+        @endpoints.each { |ep| @policy.good(ep, 0, Time.now) }
+      end
+
+      it 'reports all endpoints as green' do
+        expected_stats = {}
+        @endpoints.each { |ep| expected_stats[ep] = 'green' }
+
+        @policy.get_stats.should_not be_nil
+        @policy.get_stats.should == expected_stats
+      end
+    end
+
+    context 'given all red servers' do
+      it 'reports all endpoints as red' do
+        expected_stats = {}
+        @endpoints.each { |ep| expected_stats[ep] = 'red' }
+
+        @endpoints.each do |endpoint|
+          @yellow_states.times { @policy.bad(endpoint, 0, Time.now) }
+        end
+
+        @policy.get_stats.should_not be_nil
+        @policy.get_stats.should == expected_stats
+      end
+    end
+
+    context 'given all yellow-N servers' do
+      it 'reports all endpoints as yellow-N' do
+        expected_stats = {}
+        @endpoints.each { |ep| expected_stats[ep] = "yellow-#{@yellow_states - 1}" }
+
+        @endpoints.each do |endpoint|
+          @yellow_states.times { @policy.bad(endpoint, 0, Time.now) }
+          @policy.good(endpoint, 0, Time.now)
+        end
+
+        @policy.get_stats.should_not be_nil
+        @policy.get_stats.should == expected_stats
+      end
+    end
+  end
+
+  context :set_endpoints do
+    context 'given endpoints stack does not exist' do
+      before(:each) do
+        @policy = RightSupport::Net::LB::HealthCheck.new({
+                    :yellow_states => @yellow_states, :reset_time => @reset_time})
+      end
+
+      it 'acts as initializer' do
+        @policy.set_endpoints(@endpoints)
+        @endpoints.include?(@policy.next.first).should be_true
+      end
+    end
+
+    context 'given an existing endpoints stack' do
+      it 'updates composition and saves previous statuses of endpoints' do
+        expected_stats = {}
+        @endpoints.each { |ep| expected_stats[ep] = "yellow-#{@yellow_states - 1}" }
+
+        @endpoints.each do |endpoint|
+          @yellow_states.times { @policy.bad(endpoint, 0, Time.now) }
+          @policy.good(endpoint, 0, Time.now)
+        end
+
+        @new_endpoins = [6,7]
+        @new_endpoins.each { |ep| expected_stats[ep] = "yellow-1" }
+
+        @updated_endpoints = @endpoints + @new_endpoins
+        @policy.set_endpoints(@updated_endpoints)
+        @policy.get_stats.should eql(expected_stats)
+      end
+    end
+  end #:set_endpoints
+end

data/spec/net/balancing/round_robin_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe RightSupport::Net::LB::RoundRobin do
+  before(:each) do
+    @endpoints = [1,2,3,4,5]
+    @policy = RightSupport::Net::LB::RoundRobin.new()
+    @policy.set_endpoints(@endpoints)
+  end
+
+  it 'chooses fairly' do
+    test_random_distribution do
+      @policy.next
+    end
+  end
+end

data/spec/net/balancing/sticky_policy_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe RightSupport::Net::LB::Sticky do
+
+  before(:all) do
+    @endpoints = [1,2,3,4,5]
+    @trials = 2500
+  end
+
+  before(:each) do
+    @policy = RightSupport::Net::LB::Sticky.new({})
+  end
+
+  context :initialize do
+    it 'creates policy with an empty list of endpoints' do
+      @policy.next.should be_nil
+    end
+  end
+
+  context :next do
+
+    before(:each) do
+      @policy.set_endpoints(@endpoints)
+    end
+
+    context 'given all servers are healthy' do
+      it 'sticks to chosen one' do
+        chance = 1.0
+        seen = find_empirical_distribution(@trials,@endpoints) do 
+          @policy.next
+        end
+        seen.each_pair do |_, count|
+          (Float(count) / Float(@trials)).should be_within(0.025).of(chance) #allow 5% margin of error
+        end
+      end
+    end
+
+    context 'given a chosen server becomes unavailable' do
+      it 'chooses the next server and sticks to it' do
+        @ep1 = @policy.next.first
+
+        seen = find_empirical_distribution(@trials,@endpoints) do
+          @policy.next
+        end
+        seen[[@ep1,false]].should eql(@trials)
+
+        @policy.bad(@chosen,0,0)
+        @ep2 = @policy.next.first
+
+        seen = find_empirical_distribution(@trials,@endpoints) do
+          @policy.next
+        end
+        seen[[@ep1,false]].should be_nil
+        seen[[@ep2,false]].should eql(@trials)
+      end
+    end
+  end
+
+  context :set_endpoints do
+    context 'given an empty list of endpoints' do
+      it 'acts as initializer' do
+        @policy.next.should be_nil
+        @policy.set_endpoints(@endpoints)
+        @endpoints.include?(@policy.next.first).should be_true
+      end
+    end
+
+    context 'given an existing list endpoints' do
+      before(:each) do
+        @policy.set_endpoints(@endpoints)
+      end
+
+      context 'and updated list of endpoints contains a chosen server' do
+        it 'updates composition, but still using chosen server' do
+          @chosen_endpoint = @policy.next.first
+          @updated_endpoints = @endpoints + [6,7]
+          @policy.set_endpoints(@updated_endpoints)
+          @policy.next.first.should be_eql(@chosen_endpoint)
+        end
+      end
+
+      context 'and updated list of endpoints does not contain a chosen server' do
+        it 'updates composition and chooses new server' do
+          @chosen_endpoint = @policy.next.first
+          @updated_endpoints = @endpoints - [@chosen_endpoint]
+          @policy.set_endpoints(@updated_endpoints)
+          @policy.next.first.should_not be_eql(@chosen_endpoint)
+        end
+      end
+    end
+  end #:set_endpoints
+end