right_support 2.6.17 → 2.7.0

data/spec/net/dns_spec.rb

@@ -0,0 +1,152 @@
+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) { ['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) { ['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) { ['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).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).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) { ['1.1.1.1', '2.2.2.2', '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).sort.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).sort.should == output.sort
+        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'=>['1.1.1.1', '2.2.2.2'],
+                      'www.example2.com'=>['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

data/spec/net/http_client_spec.rb

@@ -0,0 +1,171 @@
+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,
+             :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,
+             :open_timeout=>3,
+             :url=>'/moo', :headers=>{:joe=>:blow}}
+        flexmock(RestClient::Request).should_receive(:execute).with(p)
+        @http_client.get('/moo', :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],
+             :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],
+             :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,
+             :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],
+              :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