right_support 2.11.3 → 2.12.1

data/spec/net/http_client_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Net::HTTPClient do
-  it 'has a distinct method for common HTTP verbs' do
-    @http_client = RightSupport::Net::HTTPClient.new()
-    @http_client.should respond_to(:get)
-    @http_client.should respond_to(:post)
-    @http_client.should respond_to(:put)
-    @http_client.should respond_to(:delete)
-  end
-
-  context 'with defaults passed to initializer' do
-    before(:all) do
-      @http_client = RightSupport::Net::HTTPClient.new(:open_timeout=>999, :timeout=>101010,
-                                                       :headers=>{:moo=>:bah})
-    end
-    
-    context :process_query_string do
-      it 'process nil url and params' do
-         @http_client.instance_eval { process_query_string }.should == ''
-      end
-      it 'process empty String params' do
-        url = '/moo'
-        params = ''
-        @http_client.instance_eval { process_query_string(url, params) }.should == '/moo'
-      end
-      it 'process params just with question mark' do
-        url = '/moo'        
-        params = '?'
-        @http_client.instance_eval { process_query_string(url, params) }.should == '/moo'
-      end
-      it 'process String params with question mark in the beginning' do
-        url = '/moo'
-        params = '?a=b'
-        @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a=b'
-      end
-      it 'process String params without question mark in the beginning' do
-        url = '/moo'
-        params = 'a=b&c=d'
-        @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a=b&c=d'
-      end
-
-      context 'when converting with Addressable::URI' do
-        it 'process raw Hash params' do
-          url = '/moo'
-          params = {:a=>:b}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a=b'
-        end
-        it 'process Hash params with hash inside' do
-          url = '/moo'
-          params = {:a=>{:b=>:c}}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a[b]=c'
-        end
-        it 'process Hash params with array inside' do
-          url = '/moo'
-          params = {:a=>['b','c']}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a[0]=b&a[1]=c'
-        end
-        it 'process Hash params with nested array inside' do
-          url = '/moo'
-          params = {:a=>{:b=>:c,:d=>['e','f'],:g=>{:h=>'i'}},:j=>'k'}
-          @http_client.instance_eval { process_query_string(url, params) }.should ==
-              '/moo?a[b]=c&a[d][0]=e&a[d][1]=f&a[g][h]=i&j=k'
-        end
-      end
-
-      context 'when converting directly' do
-        before(:each) do
-          flexmock(@http_client).should_receive(:require_succeeds?).with('addressable/uri').and_return(false)
-        end
-
-        it 'process raw Hash params' do
-          url = '/moo'
-          params = {:a=>:b}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a=b'
-        end
-        it 'process Hash params with hash inside' do
-          url = '/moo'
-          params = {:a=>{:b=>:c}}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a%5Bb%5D=c'
-        end
-        it 'process Hash params with array inside' do
-          url = '/moo'
-          params = {:a=>['b','c']}
-          @http_client.instance_eval { process_query_string(url, params) }.should == '/moo?a%5B%5D=b&a%5B%5D=c'
-        end
-        it 'process Hash params with nested array inside' do
-          url = '/moo'
-          params = {:a=>{:b=>:c,:d=>['e','f'],:g=>{:h=>'i'}},:j=>'k'}
-          @http_client.instance_eval { process_query_string(url, params) }.should ==
-              '/moo?a%5Bb%5D=c&a%5Bd%5D%5B%5D=e&a%5Bd%5D%5B%5D=f&a%5Bg%5D%5Bh%5D=i&j=k'
-        end
-      end
-    end
-
-    context :request do
-      it 'uses default options on every request' do
-        p = {:method=>:get,
-             :timeout=>101010,
-             :ssl_version=>'TLSv1',
-             :open_timeout=>999,
-             :url=>'/moo', :headers=>{:moo=>:bah}}
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-        @http_client.get('/moo')
-      end
-
-      it 'allows defaults to be overridden' do
-        p = {:method=>:get,
-             :timeout=>101010,
-             :ssl_version=>'SSLv3',
-             :open_timeout=>3,
-             :url=>'/moo', :headers=>{:joe=>:blow}}
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-        @http_client.get('/moo', :ssl_version => 'SSLv3', :open_timeout=>3, :headers=>{:joe=>:blow})
-      end
-    end
-  end
-
-  context :request do
-    before(:each) do
-      r = 'this is a short mock REST response'
-      flexmock(RestClient::Request).should_receive(:execute).and_return(r).by_default
-      @http_client = RightSupport::Net::HTTPClient.new()
-    end
-
-    context 'given just a URL' do
-      it 'succeeds' do
-        p = {:method=>:get,
-             :timeout=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:timeout],
-             :ssl_version=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:ssl_version],
-             :open_timeout=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:open_timeout],
-             :url=>'/moo', :headers=>{}}
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-
-        @http_client.get('/moo')
-      end
-    end
-
-    context 'given a URL and headers' do
-      it 'succeeds' do
-        p = {:method=>:get,
-             :timeout=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:timeout],
-             :ssl_version=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:ssl_version],
-             :open_timeout=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:open_timeout],
-             :url=>'/moo', :headers=>{:mrm=>1, :blah=>:foo}}
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-
-        @http_client.get('/moo', {:headers => {:mrm=>1, :blah=>:foo}})
-      end
-    end
-
-
-    context 'given a timeout, no headers, and a URL' do
-      it 'succeeds' do
-        p = {:method=>:get,
-             :timeout=>42,
-             :ssl_version=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:ssl_version],
-             :open_timeout => RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:open_timeout],
-             :url=>'/moo', :headers=>{}}
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-
-        @http_client.get('/moo', {:timeout => 42})
-      end
-    end
-    
-    context 'given a URL and any other parameters' do
-      it 'succeeds' do
-        p = { :method=>:get,
-              :timeout=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:timeout],
-              :ssl_version=>RightSupport::Net::HTTPClient::DEFAULT_OPTIONS[:ssl_version],
-              :url=>'/moo',
-              :headers=>{},
-              :open_timeout => 1,
-              :payload=>{:foo => :bar} }
-        flexmock(RestClient::Request).should_receive(:execute).with(p)
-
-        @http_client.get('/moo', :open_timeout => 1, :payload=>{:foo => :bar})
-      end
-    end
-  end
-end

data/spec/net/lb/health_check_spec.rb

@@ -1,417 +0,0 @@
-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,
-                :health_check => lambda { |ep| true })
-    @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 },
-          :health_check => lambda { |ep| true })
-        @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 },
-          :health_check => lambda { |ep| true })
-        @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 "eliminates bad endpoints during round robin selection" do
-        endpoints = [1, 2, 3, 4, 5]
-        policy = RightSupport::Net::LB::HealthCheck.new(
-          :yellow_states => 2,
-          :health_check => lambda { |ep| true })
-        policy.set_endpoints(endpoints)
-        policy.instance_variable_set(:@counter, 0)
-        breaking_bad = lambda { |ep| ep < 4 }
-
-        # first pass; initially all green, mark some yellow.
-        expected = [1, 2, 3, 4, 5]
-        actual = []
-        endpoints.size.times do
-          endpoint, need_health_check = policy.next
-          need_health_check.should be_false
-          if breaking_bad.call(endpoint)
-            policy.bad(endpoint, 0, Time.now)  # go yellow
-          end
-          actual << endpoint
-        end
-        actual.should == expected
-
-        # second pass; some yellow, others green. yellows go red after being
-        # selected and are eliminated from subsequent round-robin selection.
-        expected = [1, 4, 5, 2, 3]
-        actual = []
-        endpoints.size.times do
-          endpoint, need_health_check = policy.next
-          if breaking_bad.call(endpoint)
-            # yellow is still viable but a health-check is requested.
-            need_health_check.should be_true
-            policy.bad(endpoint, 0, Time.now)  # go red
-          else
-            need_health_check.should be_false
-          end
-          actual << endpoint
-        end
-        actual.should == expected
-
-        # third pass; green or red, no more yellow.
-        expected = [4, 5, 4, 5, 4]
-        actual = []
-        endpoints.size.times do
-          endpoint, need_health_check = policy.next
-          need_health_check.should be_false
-          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,
-          :health_check => lambda { |ep| true })
-      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/lb/round_robin_spec.rb

@@ -1,15 +0,0 @@
-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/lb/sticky_spec.rb

@@ -1,92 +0,0 @@
-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