right_support 2.11.3 → 2.12.1

data/spec/log/mixin_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-
-class InnocentVictim
-  include RightSupport::Log::Mixin
-end
-
-class Bystander < InnocentVictim
-end
-
-module Parasite
-  include RightSupport::Log::Mixin
-end
-
-class Host
-  include Parasite
-end
-
-describe RightSupport::Log::Mixin do
-  context 'when mixed into a module' do
-    before(:each) do
-      @victim = Host.new
-    end
-
-    it 'provides instance-level accesssor to hosts' do
-      @victim.should respond_to(:logger)
-      @victim.should respond_to(:logger=)
-      @victim.logger.info 'haha'
-    end
-
-    it 'provides a module-method-level accessor' do
-      Parasite.should respond_to(:logger)
-      Parasite.should respond_to(:logger=)
-      Parasite.logger.info 'haha'
-    end
-  end
-
-  context 'when mixed into a base class' do
-    before(:each) do
-      @victim = InnocentVictim.new
-    end
-
-    it 'provides a class-level accessor' do
-      @victim.class.should respond_to(:logger)
-      @victim.class.should respond_to(:logger=)
-      @victim.class.logger.info 'haha'
-    end
-
-    it 'provides an instance-level accessor' do
-      @victim.should respond_to(:logger)
-      @victim.should respond_to(:logger=)
-      @victim.logger.info 'haha'
-    end
-
-    context :logger do
-      context 'without a logger' do
-        before(:each) do
-          @victim.class.logger = nil
-        end
-
-        it 'uses the default logger' do
-          flexmock(RightSupport::Log::Mixin.default_logger).should_receive(:info).twice.and_return(true)
-          @victim.class.logger.info('lalalala').should be_true
-          @victim.logger.info('lalalala').should be_true
-        end
-      end
-
-      context 'with class logger' do
-        before(:each) do
-          @logger = mock_logger
-          @victim.class.logger = @logger
-        end
-
-        it 'uses class logger' do
-          @logger.should_receive(:info).and_return(true).twice
-          @victim.class.logger.info('lalalala').should be_true
-          @victim.logger.info('lalalala').should be_true
-        end
-
-        context 'with instance logger' do
-          before(:each) do
-            @instance_logger = mock_logger
-            @victim.logger = @instance_logger
-          end
-
-          it 'uses instance logger' do
-            @instance_logger.should_receive(:info).and_return(true).once
-            @logger.should_receive(:info).never
-            @victim.logger.info('lalalala').should be_true
-          end
-        end
-      end
-    end
-  end
-
-  context 'when inherited from a base class' do
-    let(:base_logger) { flexmock('base-class logger') }
-    let(:subclass_logger) { flexmock('derived-class logger') }
-
-    after(:each) do
-      InnocentVictim.logger = nil
-      Bystander.logger = nil
-    end
-
-    it 'delegates to base class' do
-      InnocentVictim.logger = base_logger
-      base_logger.should_receive(:error).with('foo').once
-
-      Bystander.logger.error('foo')
-    end
-
-    it 'allows override in child class' do
-      InnocentVictim.logger = base_logger
-      Bystander.logger = subclass_logger
-      base_logger.should_receive(:error).never
-      subclass_logger.should_receive(:error).with('foo').once
-
-      Bystander.logger.error('foo')
-    end
-  end
-
-  context 'given someone has defined Class#logger' do
-    before(:all) do
-      InnocentVictim.logger = nil
-      class Class
-        def logger
-          raise "THIS SHOULD NEVER BE CALLED"
-        end
-      end
-    end
-
-    after(:all) do
-      class Class
-        remove_method :logger
-      end
-    end
-
-    it 'should never delegate to Class#logger' do
-      InnocentVictim.logger.info 'test log'
-    end
-  end
-end

data/spec/log/multiplexer_spec.rb

@@ -1,54 +0,0 @@
-#
-# Copyright (c) 2009-2012 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 'spec_helper'
-
-describe RightSupport::Log::Multiplexer do
-
-  before(:all) do
-    @target1 = RightSupport::Log::NullLogger.new
-    @target2 = RightSupport::Log::NullLogger.new
-    @target3 = RightSupport::Log::NullLogger.new
-    @multiplexer = RightSupport::Log::Multiplexer.new(@target1, @target2, @target3)
-  end
-
-  it 'multiplexes method calls to all callers' do
-    flexmock(@target1).should_receive(:some_method).with('arg', 'arg2').once
-    flexmock(@target2).should_receive(:some_method).with('arg', 'arg2').once
-    flexmock(@target3).should_receive(:some_method).with('arg', 'arg2').once
-    @multiplexer.some_method('arg', 'arg2')
-  end
-
-  it 'returns the result returned by the first target' do
-    flexmock(@target1).should_receive(:some_method).with('arg', 'arg2').and_return('res1').once
-    flexmock(@target2).should_receive(:some_method).with('arg', 'arg2').and_return('res2').once
-    flexmock(@target3).should_receive(:some_method).with('arg', 'arg2').and_return('res3').once
-    @multiplexer.some_method('arg', 'arg2').should == 'res1'
-  end
-
-  it 'multiplexes #warn by undefining Object#warn' do
-    flexmock(@target1).should_receive(:warn).with('arg').and_return('res1')
-    flexmock(@target2).should_receive(:warn).with('arg').and_return('res2')
-    flexmock(@target3).should_receive(:warn).with('arg').and_return('res3')
-    @multiplexer.warn('arg').should == 'res1'
-  end
-end

data/spec/log/null_logger_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Log::NullLogger do
-  before(:each) do
-    @logger = RightSupport::Log::NullLogger.new
-  end
-
-  context 'log levels' do
-    [:debug, :info, :warn, :error, :fatal].each do |method|
-      it "responds to ##{method}" do
-        block_called = false
-        @logger.__send__(method, 'lalalala').should be_true
-        @logger.__send__(method) { block_called = true ; 'lalalala' }.should be_true
-        block_called.should be_true
-      end
-    end
-  end
-
-  context '<< method' do
-    it 'responds like Logger' do
-      (@logger << 'lalalala').should == 8
-    end
-  end
-
-  context :close do
-    it 'responds' do
-      @logger.close.should be_nil
-    end
-
-    it 'is idempotent' do
-      @logger.close.should be_nil
-      @logger.close.should be_nil
-      @logger.close.should be_nil
-    end
-  end
-end

data/spec/log/step_level_logger_spec.rb

@@ -1,49 +0,0 @@
-require ::File.expand_path('../../spec_helper', __FILE__)
-require 'stringio'
-
-describe RightSupport::Log::StepLevelLogger do
-  context 'with a decorated logger' do
-    let(:buffer) { ::StringIO.new }
-
-    let(:decorated_logger) { ::Logger.new(buffer) }
-
-    def try_all_levels(l)
-      l.debug('debug')
-      l.info('info')
-      l.warn('warn')
-      l.error('error')
-      l.fatal('fatal')
-    end
-
-    context 'with default level' do
-      subject { described_class.new(decorated_logger) }
-
-      it 'passes all messages' do
-        try_all_levels(subject)
-        buffer.string.should =~ /debug.+info.+warn.+error.+fatal/m
-      end
-    end
-
-    context 'with error level' do
-      subject do
-        s = described_class.new(decorated_logger)
-        s.level = ::Logger::ERROR
-        s
-      end
-
-      it 'passes error and fatal messages' do
-        try_all_levels(subject)
-        buffer.string.should_not =~ /debug/
-        buffer.string.should_not =~ /info/
-        buffer.string.should_not =~ /warn/
-        buffer.string.should =~ /error.+fatal/m
-      end
-
-      it 'does not change level of decorated logger' do
-        try_all_levels(decorated_logger)
-        buffer.string.should =~ /debug.+info.+warn.+error.+fatal/m
-      end
-    end
-
-  end
-end

data/spec/log/system_logger_spec.rb

@@ -1,172 +0,0 @@
-require 'spec_helper'
-require 'socket'
-
-# 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
-
-  after(:each) do
-    subject.instance_eval { class_variable_set(:@@syslog, nil) }
-  end
-
-  context :local do
-    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
-      @mock_syslog.should_receive(:info).with('Connected to syslog: :local').once
-    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).and_return(@mock_syslog)
-            subject.new('unit tests', :facility=>name, :connection=>:local)
-          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', :connection=>:local)
-            @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', :connection=>:local)
-        @mock_syslog.should_receive(:info).with('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, :connection=>:local)
-
-          actual = []
-          @mock_syslog.should_receive(:info).and_return do |message|
-            actual << message
-            true
-          end
-
-          @logger.info("This is a\nmulti line\r\nlog message\n\rwith all kinds\n\n\rof stuff")
-          actual.should == ["This is a", "multi line", "log message", "with all kinds", "of stuff"]
-        end
-
-        it 'when false, passes through multi-line messages' do
-          @logger = subject.new('spec', :split=>false, :connection=>:local)
-
-          actual = []
-          @mock_syslog.should_receive(:info).and_return do |message|
-            actual << message
-            true
-          end
-
-          msg = "This is a\nmulti line\r\nlog message\n\rwith all kinds\n\n\rof stuff"
-          @logger.info(msg)
-          actual.should == [msg]
-        end
-      end
-
-      context 'given :color option' do
-        it 'when true, passes through ANSI color codes' do
-          @logger = subject.new('spec', :color=>true, :connection=>:local)
-
-          actual = []
-          @mock_syslog.should_receive(:info).and_return do |message|
-            actual << message
-            true
-          end
-
-          msg = "This has \e[16;32mcolor\e[7;0m inside it!"
-          @logger.info(msg)
-          actual.should == [msg]
-        end
-
-        it 'when false, strips out ANSI color codes' do
-          @logger = subject.new('spec', :color=>false, :connection=>:local)
-
-          actual = []
-          @mock_syslog.should_receive(:info).and_return do |message|
-            actual << message
-            true
-          end
-
-          @logger.info("This has \e[16;32mcolor\e[7;0m inside it!")
-          actual.should == ['This has color inside it!']
-        end
-      end
-    end
-  end
-
-  context :remote do
-    it 'sends protocol-formatted messages to a syslog service' do
-      server = ::TCPServer.new(2345)
-      data = nil
-      ::Thread.start do
-        client = server.accept
-        data = client.readline
-        client.close
-      end
-      logger = subject.new('spec', :connection=>'tcp://localhost:2345')
-      stop_time = ::Time.now + 3
-      while data.nil?
-        sleep(0.1)
-        fail 'Did not receive expected data' if ::Time.now >= stop_time
-      end
-
-      # example: "<134> Sep 23 13:45:42 ubuntu spec[3891]: Connected to syslog: \"tcp://localhost:2345\"\n"
-      regex = /^<134> \w+ \d+ \d+:\d+:\d+ .+ spec\[\d+\]: Connected to syslog: \"tcp:\/\/localhost:2345\"$/
-      data.chomp.should match(regex)
-
-      # attempt to reconnect to closed server.
-      server.close
-      server = nil
-      data = nil
-      ::Thread.start do
-        sleep 1  # should cause 1-2 reconnect error(s) to appear in STDERR
-        server = ::TCPServer.new(2345)
-        client = server.accept
-        data = client.readline
-        client.close
-        server.close
-        server = nil
-      end
-
-      # explicitly reconnect and send with delayed server restart. reconnection
-      # happens automagically (only for remote) but explicit reconnection will
-      # reestablish the PID, etc., which is useful for forking.
-      logger.reconnect
-      logger.debug("Hello syslog")
-      stop_time = ::Time.now + 3
-      while data.nil?
-        sleep(0.1)
-        fail 'Did not receive expected data' if ::Time.now >= stop_time
-      end
-      regex = /^<135> \w+ \d+ \d+:\d+:\d+ .+ spec\[\d+\]: Hello syslog$/
-      data.chomp.should match(regex)
-    end
-  end
-
-end if defined?(RightSupport::Log::SystemLogger)

data/spec/net/address_helper_spec.rb

@@ -1,57 +0,0 @@
-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/dns_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper'
-
-describe RightSupport::Net::DNS do
-  include SpecHelper::SocketMocking
-
-  subject { RightSupport::Net::DNS } #the module itself
-
-  context :resolve_all_ip_addresses do
-    before(:all) do
-      @hostnames = ['1.1.1.1', '2.2.2.2', '3.3.3.3']
-      @hostnames .each do |hostname|
-        flexmock(Socket).should_receive(:getaddrinfo).with(hostname, 443, Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP).once.and_return([[0,0,0,hostname]])
-      end
-    end
-    it 'resolves all ip addresses for specified array of endpoints' do
-      @resolved_hostnames = subject.resolve_all_ip_addresses(@hostnames)
-      (@resolved_hostnames - @hostnames).should be_eql([])
-    end
-  end
-
-
-  context :resolve do
-    context 'given default :retry => 3' do
-      let(:endpoint) { 'www.example.com' }
-      let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2'])] }
-
-      it 'retries SocketError' do
-        mock_getaddrinfo('www.example.com', SocketError)
-        mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-
-        subject.resolve(endpoint).should == output
-      end
-
-      it 'stops retrying SocketError after three attempts' do
-        mock_getaddrinfo('www.example.com', SocketError, 3)
-
-        expect { subject.resolve(endpoint) }.to raise_error(SocketError)
-      end
-
-      it 'does not rescue other exceptions' do
-        mock_getaddrinfo('www.example.com', ArgumentError)
-
-        expect { subject.resolve(endpoint) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'given :retry => 0' do
-      it 'does not retry SocketError' do
-        mock_getaddrinfo('www.example.com', SocketError)
-
-        expect { subject.resolve('www.example.com', :retry=>0) }.to raise_error(SocketError)
-      end
-    end
-
-    context 'given various endpoint formats' do
-      context 'e.g. a DNS hostname' do
-        let(:endpoint) { 'www.example.com' }
-        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2'])] }
-
-        it 'resolves to IP addresses' do
-          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          subject.resolve(endpoint).should == output
-        end
-      end
-
-      context 'e.g. an IPv4 address' do
-        let(:endpoint) { '127.0.0.1' }
-        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['127.0.0.1'])] }
-
-        it 'resolves to the same address' do
-          mock_getaddrinfo('127.0.0.1', ['127.0.0.1'])
-          subject.resolve(endpoint).should == output
-        end
-      end
-
-      context 'e.g. an HTTP URL' do
-        let(:endpoint) { 'http://www.example.com' }
-        let(:output) { ['http://1.1.1.1', 'http://2.2.2.2'] }
-
-        it 'resolves to URLs with addresses substituted' do
-          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          subject.resolve(endpoint).first.addrs.should == output
-        end
-
-        context 'with a path component' do
-          let(:endpoint) { 'http://www.example.com/foo/bar' }
-          let(:output) { ['http://1.1.1.1/foo/bar', 'http://2.2.2.2/foo/bar'] }
-
-          it 'resolves to URLs with path component preserved' do
-            mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-            subject.resolve(endpoint).first.addrs.should == output
-          end
-        end
-      end
-
-      # The double slash in a URI indicates that an authority follows. The authority
-      # is interpreted as a hostname for most URL schemes we are interested in. We
-      # can't deal with URLs unless they have a clear authority/hostname that we
-      # can substitute.
-      #
-      # For more information, see: http://tools.ietf.org/html/rfc3986#section-3
-      context 'e.g. a URI without an authority' do
-        let(:endpoint) { 'urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66' }
-
-        it 'raises URI::InvalidURIError' do
-          lambda do
-            subject.resolve(endpoint)
-          end.should raise_error(URI::InvalidURIError)
-        end
-      end
-
-      context 'e.g. several hostnames' do
-        let(:endpoints) { ['www.example.com', 'www.example.net'] }
-        let(:output) { [RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2']), RightSupport::Net::ResolvedEndpoint.new(['3.3.3.3', '4.4.4.4'])] }
-
-        it 'resolves to IP addresses' do
-          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          mock_getaddrinfo('www.example.net', ['3.3.3.3', '4.4.4.4'])
-
-          subject.resolve(endpoints).should == output
-        end
-      end
-
-      context 'e.g. several HTTP URLs' do
-        let(:endpoints) { ['http://www.example.com', 'http://www.example.net'] }
-        let(:output) { ['http://1.1.1.1', 'http://2.2.2.2', 'http://3.3.3.3', 'http://4.4.4.4'] }
-
-        it 'resolves to URLs with addresses substituted' do
-          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          mock_getaddrinfo('www.example.net', ['3.3.3.3', '4.4.4.4'])
-
-          subject.resolve(endpoints).map {|ep| ep.addrs}.flatten == output
-        end
-      end
-    end
-
-    context 'requesting CIDR blocks' do
-      context 'DNS resolvable addresses' do
-        let(:endpoint) { 'www.example.com' }
-        let(:output) { ['1.1.1.1/32', '2.2.2.2/32'] }
-
-        it 'resolves hostname to CIDR /32 blocks' do
-          mock_getaddrinfo('www.example.com', ['1.1.1.1', '2.2.2.2'])
-          subject.resolve(endpoint).first.blocks.should == output
-        end
-
-        it 'resolves IP addresses to CIDR /32 blocks' do
-          mock_getaddrinfo('1.1.1.1', ['1.1.1.1'])
-          mock_getaddrinfo('2.2.2.2', ['2.2.2.2'])
-          subject.resolve(['1.1.1.1', '2.2.2.2']).map {|endpoint| endpoint.blocks}.flatten.should =~ output
-        end
-
-        it 'refuses to resolve a URI having a CIDR block < /32' do
-          lambda do
-            subject.resolve("http://cf-mirror.rightscale.com")
-          end.should raise_error(URI::InvalidURIError)
-        end
-      end
-
-      context 'Static CIDR blocks' do
-        let(:endpoint) { 'cf-mirror.rightscale.com' }
-
-        it 'resolves hostname to static CIDR blocks' do
-          subject.resolve(endpoint).first.blocks.each do |addr|
-            # Addresses should all be in CIDR form and not single /32 addresses
-            addr.should =~ /^\d+(?:\.\d+){3}\/(?:#{1.upto(31).to_a.join('|')})$/
-          end
-        end
-      end
-    end
-  end
-
-  context :resolve_with_hostnames do
-    context 'given common inputs' do
-      let(:endpoints) { ['www.example1.com','www.example2.com'] }
-      let(:output) { {'www.example1.com'=>RightSupport::Net::ResolvedEndpoint.new(['1.1.1.1', '2.2.2.2']),
-                      'www.example2.com'=>RightSupport::Net::ResolvedEndpoint.new(['3.3.3.3', '4.4.4.4'])} }
-
-      it 'resolves to IP addresses' do
-        mock_getaddrinfo('www.example1.com', ['1.1.1.1', '2.2.2.2'])
-        mock_getaddrinfo('www.example2.com', ['3.3.3.3', '4.4.4.4'])
-        subject.resolve_with_hostnames(endpoints).should == output
-      end
-    end
-  end
-
-end