cf-uaa-lib 3.6.0 → 3.14.3

data/spec/http_spec.rb

@@ -15,83 +15,128 @@ require 'spec_helper'
 require 'uaa/http'
 require 'uaa/version'
 
-module CF::UAA
-
-describe Http do
+describe CF::UAA::Http do
 
   class HttpTest
-    include Http
+    include CF::UAA::Http
 
     public :http_get
   end
 
   let(:http_instance) { HttpTest.new }
 
-  it "sets a request handler" do
-    http_instance.set_request_handler do |url, method, body, headers|
-      [200, "body", {"content-type" => "text/plain"}]
+  let(:http_double) do
+    http_double = double('http').as_null_object
+    expect(HTTPClient).to receive(:new).and_return(http_double)
+    http_double
+  end
+
+  let(:cert_store) { double('OpenSSL::X509::Store') }
+
+  describe 'set_request_handler' do
+    it 'sets a request handler' do
+      http_instance.set_request_handler do |url, method, body, headers|
+        [200, 'body', {'content-type' => 'text/plain'}]
+      end
+      status, body, resp_headers = http_instance.http_get('http://example.com')
+      status.should == 200
+      body.should == 'body'
+      resp_headers['content-type'].should == 'text/plain'
     end
-    status, body, resp_headers = http_instance.http_get("http://example.com")
-    status.should == 200
-    body.should == "body"
-    resp_headers["content-type"].should == "text/plain"
   end
 
-  it "utilizes proxy settings if given" do
-    reply_double = double('http reply', each_header: {}).as_null_object
-    http_double = double('http', request: reply_double, new: nil)
-    Net::HTTP.stub(:new).and_return(http_double)
-    http_instance.http_proxy = 'user:password@http-proxy.example.com:1234'
-    http_instance.https_proxy = 'user:password@https-proxy.example.com:1234'
+  describe 'http_get' do
 
-    http_instance.http_get("http://example.com")
+    context 'when response has no status' do
+      let(:response) { double('http::message') }
+      it 'raises an HTTPException error' do
+        expect(response).to receive(:status)
+        expect(response).to receive(:content).and_return('TEST')
+        expect(http_double).to receive(:get).and_return(response)
+        expect { http_instance.http_get('https://example.com') }.to raise_error(CF::UAA::HTTPException, "Can't parse response from the server TEST")
+      end
+    end
 
-    expect(Net::HTTP).to have_received(:new).with(anything, anything, 'http-proxy.example.com', 1234, 'user', 'password')
-  end
+    context 'when certificate is not valid' do
+      it 'raises an SSLException' do
+        expect(http_double).to receive(:get).and_raise(OpenSSL::SSL::SSLError)
 
-  it "raises an SSLException when the certificate is not valid" do
-    http_double = double('http').as_null_object
-    Net::HTTP.stub(:new).and_return(http_double)
-    http_double.stub(:request).and_raise(OpenSSL::SSL::SSLError)
+        expect { http_instance.http_get('https://example.com') }.to raise_error(CF::UAA::SSLException)
+      end
+    end
 
-    expect { http_instance.http_get("https://example.com") }.to raise_error(CF::UAA::SSLException)
-  end
+    context 'when skipping ssl validation' do
+      let(:ssl_config) { double('ssl_config') }
 
-  it "skips ssl validation if requested" do
-    http_double = double('http').as_null_object
-    Net::HTTP.stub(:new).and_return(http_double)
-    http_double.stub(:verify_mode=)
+      it 'sets verify mode to VERIFY_NONE' do
+        http_instance.initialize_http_options({skip_ssl_validation: true})
 
-    http_instance.http_get("https://example.com")
-    expect(http_double).not_to have_received(:verify_mode=)
+        expect(http_double).to receive(:ssl_config).and_return(ssl_config)
+        expect(ssl_config).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+        http_instance.http_get('https://uncached.example.com')
+      end
+    end
 
-    http_instance.skip_ssl_validation = true
-    http_instance.http_get("https://uncached.example.com")
-    expect(http_double).to have_received(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
-  end
+    context 'when validating ssl' do
+      let(:ssl_config) { double('ssl_config') }
 
-  it "passes ssl certificate file if provided" do
-    http_double = double('http').as_null_object
-    Net::HTTP.stub(:new).and_return(http_double)
+      it 'sets default values' do
+        expect(http_double).to receive(:ssl_config).and_return(ssl_config)
+        expect(ssl_config).to receive(:set_default_paths)
+        http_instance.http_get('https://example.com')
+      end
+    end
 
-    http_instance.ssl_ca_file = "/fake-ca-file"
-    http_instance.http_get("https://uncached.example.com")
+    context 'when ssl certificate is provided' do
+      let(:ssl_config) { double('ssl_config') }
 
-    expect(http_double).to have_received(:ca_file=).with("/fake-ca-file")
-    expect(http_double).to have_received(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-  end
+      it 'passes it' do
+        http_instance.initialize_http_options({ssl_ca_file: '/fake-ca-file'})
 
-  it "passes ssl cert store if provided" do
-    http_double = double('http').as_null_object
-    cert_store = double('OpenSSL::X509::Store')
-    Net::HTTP.stub(:new).and_return(http_double)
+        expect(http_double).to receive(:ssl_config).and_return(ssl_config).twice
+        expect(ssl_config).to receive(:set_trust_ca).with('/fake-ca-file')
+        expect(ssl_config).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
 
-    http_instance.ssl_cert_store = cert_store
-    http_instance.http_get("https://uncached.example.com")
+        http_instance.http_get('https://uncached.example.com')
+      end
+    end
 
-    expect(http_double).to have_received(:cert_store=).with(cert_store)
-    expect(http_double).to have_received(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-  end
-end
+    context 'when ssl cert store is provided' do
+      let(:ssl_config) { double('ssl_config') }
+
+      it 'passes it' do
+        http_instance.initialize_http_options({ssl_cert_store: cert_store})
+
+        expect(http_double).to receive(:ssl_config).and_return(ssl_config).twice
+        expect(ssl_config).to receive(:cert_store=).with(cert_store)
+        expect(ssl_config).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+
+        http_instance.http_get('https://uncached.example.com')
+      end
+    end
+
+    context 'when an http request timeout is provided' do
+      it 'sets all timeouts on the http clien to the http_timeout' do
+        http_instance.initialize_http_options({http_timeout: 10})
 
+        expect(http_double).to receive(:connect_timeout=).with(10)
+        expect(http_double).to receive(:send_timeout=).with(10)
+        expect(http_double).to receive(:receive_timeout=).with(10)
+
+        http_instance.http_get('https://uncached.example.com')
+      end
+    end
+
+    context 'when an http request timeout is not provided' do
+      it 'does not override the default' do
+        http_instance.initialize_http_options({})
+
+        expect(http_double).not_to receive(:connect_timeout=)
+        expect(http_double).not_to receive(:send_timeout=)
+        expect(http_double).not_to receive(:receive_timeout=)
+
+        http_instance.http_get('https://uncached.example.com')
+      end
+    end
+  end
 end

data/spec/info_spec.rb

@@ -19,44 +19,42 @@ module CF::UAA
   describe Info do
     let(:options) { {} }
     let(:uaa_info) { Info.new(target, options) }
-    let(:target) { "https://login.cloudfoundry.com" }
+    let(:target) { 'https://login.cloudfoundry.com' }
     let(:authorization) { nil }
 
     before do
       uaa_info.set_request_handler do |url, method, body, headers|
         url.should == target_url
         method.should == :get
-        headers["content-type"].should be_nil
-        headers["accept"].gsub(/\s/, '').should =~ /application\/json;charset=utf-8/i
-        headers["authorization"].should == authorization
-        [200, response_body, {"content-type" => "application/json"}]
+        headers['content-type'].should be_nil
+        headers['accept'].gsub(/\s/, '').should =~ /application\/json;charset=utf-8/i
+        headers['authorization'].should == authorization
+        [200, response_body, {'content-type' => 'application/json'}]
       end
     end
 
-    describe "initialize" do
-      let(:options) { {:http_proxy => 'http-proxy.com', :https_proxy => 'https-proxy.com', :skip_ssl_validation => true} }
+    describe 'initialize' do
+      let(:options) { {:skip_ssl_validation => true} }
 
-      it "sets proxy information" do
-        uaa_info.http_proxy.should == 'http-proxy.com'
-        uaa_info.https_proxy.should == 'https-proxy.com'
+      it 'sets proxy information' do
         uaa_info.skip_ssl_validation == true
       end
     end
 
-    describe "getting server info" do
-      let(:target_url) { "https://login.cloudfoundry.com/login" }
+    describe 'getting server info' do
+      let(:target_url) { 'https://login.cloudfoundry.com/login' }
       let(:response_body) { '{"commit_id":"12345","prompts":["one","two"]}' }
 
-      it "gets server info" do
+      it 'gets server info' do
         result = uaa_info.server
-        result["prompts"].should_not be_nil
-        result["commit_id"].should_not be_nil
+        result['prompts'].should_not be_nil
+        result['commit_id'].should_not be_nil
       end
 
-      context "with symbolize_keys keys true" do
+      context 'with symbolize_keys keys true' do
         let(:options) { {:symbolize_keys => true} }
 
-        it "gets server info" do
+        it 'gets server info' do
           result = uaa_info.server
           result[:prompts].should_not be_nil
           result[:commit_id].should_not be_nil
@@ -64,63 +62,63 @@ module CF::UAA
       end
     end
 
-    describe "getting UAA target" do
-      let(:target) { "https://login.cloudfoundry.com" }
-      let(:target_url) { "https://login.cloudfoundry.com/login" }
+    describe 'getting UAA target' do
+      let(:target) { 'https://login.cloudfoundry.com' }
+      let(:target_url) { 'https://login.cloudfoundry.com/login' }
       let(:response_body) { '{"links":{"uaa":"https://uaa.cloudfoundry.com"},"prompts":["one","two"]}' }
 
-      it "gets UAA target" do
+      it 'gets UAA target' do
         result = uaa_info.discover_uaa
-        result.should == "https://uaa.cloudfoundry.com"
+        result.should == 'https://uaa.cloudfoundry.com'
       end
 
       context "when there is no 'links' key present" do
-        let(:target) { "https://uaa.cloudfoundry.com" }
-        let(:target_url) { "https://uaa.cloudfoundry.com/login" }
+        let(:target) { 'https://uaa.cloudfoundry.com' }
+        let(:target_url) { 'https://uaa.cloudfoundry.com/login' }
         let(:response_body) { '{ "prompts" : ["one","two"]} ' }
 
-        it "returns the target url" do
+        it 'returns the target url' do
           result = uaa_info.discover_uaa
-          result.should == "https://uaa.cloudfoundry.com"
+          result.should == 'https://uaa.cloudfoundry.com'
         end
       end
 
-      context "with symbolize_keys keys true" do
+      context 'with symbolize_keys keys true' do
         let(:options) { {:symbolize_keys => true} }
 
-        it "gets UAA target" do
+        it 'gets UAA target' do
           result = uaa_info.discover_uaa
-          result.should == "https://uaa.cloudfoundry.com"
+          result.should == 'https://uaa.cloudfoundry.com'
         end
       end
     end
 
-    describe "whoami" do
-      let(:target_url) { "https://login.cloudfoundry.com/userinfo?schema=openid" }
+    describe 'whoami' do
+      let(:target_url) { 'https://login.cloudfoundry.com/userinfo?schema=openid' }
       let(:response_body) { '{"user_id":"1111-1111-1111-1111","user_name":"user","given_name":"first","family_name":"last","name":"first last","email":"email@example.com"}' }
       let(:authorization) { 'authentication_token' }
 
-      it "returns the user info" do
+      it 'returns the user info' do
         result = uaa_info.whoami(authorization)
         result['email'].should == 'email@example.com'
       end
     end
 
-    describe "validation_key" do
-      let(:target_url) { "https://login.cloudfoundry.com/token_key" }
+    describe 'validation_key' do
+      let(:target_url) { 'https://login.cloudfoundry.com/token_key' }
       let(:response_body) { '{"alg":"SHA256withRSA","value":"-----BEGIN PUBLIC KEY-----\nabc123\n-----END PUBLIC KEY-----\n"}' }
 
-      it "returns the key data" do
+      it 'returns the key data' do
         result = uaa_info.validation_key(authorization)
         result['alg'].should == 'SHA256withRSA'
       end
     end
 
-    describe "validation keys" do
-      let(:target_url) { "https://login.cloudfoundry.com/token_keys" }
+    describe 'validation keys' do
+      let(:target_url) { 'https://login.cloudfoundry.com/token_keys' }
       let(:response_body) { '{ "keys": [ { "kid": "the_key", "alg": "SHA256withRSA", "value": "-----BEGIN PUBLIC KEY-----\nabc123\n-----END PUBLIC KEY-----\n", "kty": "RSA", "use": "sig", "n": "Ufn7Qc", "e": "EEXZ" }, { "kid": "the_other_key", "alg": "SHA256withRSA", "value": "-----BEGIN PUBLIC KEY-----\ndef456\n-----END PUBLIC KEY-----\n", "kty": "RSA", "use": "sig", "n": "AMcW9/P", "e": "AQAB" } ] }' }
 
-      it "returns a hash of keys" do
+      it 'returns a hash of keys' do
         result = uaa_info.validation_keys_hash(authorization)
 
         the_key = result['the_key']