cfoundry 0.4.21 → 0.5.0

data/spec/cfoundry/rest_client_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe CFoundry::RestClient do
+  let(:token) { nil }
+  let(:rest_client) { CFoundry::RestClient.new("https://api.cloudfoundry.com", token) }
+
+  describe '#request' do
+    let(:path) { "some-path" }
+    let(:url) { "https://api.cloudfoundry.com/some-path" }
+    let(:method) { "GET" }
+    let(:options) { {} }
+
+    def check_request(method = :get, &block)
+      request_stub = stub_request(method, url).to_return do |req|
+        block.call(req)
+        {}
+      end
+      subject
+      expect(request_stub).to have_been_requested
+    end
+
+    subject { rest_client.request(method, path, options) }
+
+    describe 'headers' do
+      %w[Authorization Proxy-User X-Request-Id Content-Type].each do |header_name|
+        it "should not include the #{header_name} by default" do
+          check_request do |req|
+            expect(req.headers).not_to have_key(header_name)
+          end
+        end
+      end
+
+      it "should not provide specific accept mimetypes by default" do
+        check_request do |req|
+          expect(req.headers["Accept"]).to eql("*/*")
+        end
+      end
+
+      it 'should always include a content length' do
+        check_request do |req|
+          expect(req.headers["Content-Length"]).to eql(0)
+        end
+      end
+
+      context "when a payload is passed" do
+        context "when the payload is a string" do
+          let(:options) { { :payload => "some payload"} }
+
+          it 'includes a content length matching the payload size' do
+            check_request do |req|
+              expect(req.headers["Content-Length"]).to eql("some payload".length)
+            end
+          end
+        end
+
+        context "when the payload is a hash and the content-type is JSON" do
+          let(:options) { { :payload => { "key" => "value" }, :content => :json } }
+
+          it 'includes a content length matching the JSON encoded length' do
+            check_request do |req|
+              expect(req.headers["Content-Length"]).to eql('{"key":"value"}'.length)
+            end
+          end
+        end
+
+        context "when the payload is a hash (i.e. multipart upload)" do
+          let(:method) { "PUT" }
+          let(:options) { { :payload => { "key" => "value" } } }
+
+          it 'includes a nonzero content length' do
+            check_request(:put) do |req|
+              expect(req.headers["Content-Length"].to_i).to be > 0
+            end
+          end
+        end
+      end
+
+      context 'and the token is set' do
+        let(:token_header) { "bearer something" }
+        let(:token) { CFoundry::AuthToken.new(token_header) }
+
+        it 'should include Authorization in the header' do
+          check_request do |req|
+            expect(req.headers["Authorization"]).to eq(token_header)
+          end
+        end
+      end
+
+      context 'and the request_id is set' do
+        before { rest_client.request_id = "SomeRequestId" }
+
+        it 'should include X-Request-Id in the header' do
+          check_request do |req|
+            expect(req.headers["X-Request-Id"]).to eq "SomeRequestId"
+          end
+        end
+      end
+
+      context 'and the proxy is set' do
+        before { rest_client.instance_variable_set(:@proxy, "some proxy") }
+
+        it 'should include X-Request-Id in the header' do
+          check_request do |req|
+            expect(req.headers["Proxy-User"]).to eq "some proxy"
+          end
+        end
+      end
+
+      context 'and the content is passed in' do
+        let(:options) { {:content => "text/xml"} }
+
+        it 'should include Content-Type in the header' do
+          check_request do |req|
+            expect(req.headers["Content-Type"]).to eq "text/xml"
+          end
+        end
+      end
+
+      context 'and custom headers are passed in' do
+        let(:options) { {:headers => {"X-Foo" => "Bar"}} }
+
+        it 'should include the custom header in the header' do
+          check_request do |req|
+            expect(req.headers["X-Foo"]).to eq "Bar"
+          end
+        end
+
+        context 'and it overrides an existing one' do
+          let(:options) { { :content => "text/xml", :headers => { "Content-Type" => "text/html" } } }
+
+          it 'uses the custom header' do
+            check_request do |req|
+              expect(req.headers["Content-Type"]).to eq "text/html"
+            end
+          end
+        end
+      end
+    end
+
+    describe 'payload' do
+
+    end
+
+    describe 'errors' do
+    end
+
+    describe "the return value" do
+      before do
+        stub_request(:get, url).to_return({
+          :status => 201,
+          :headers => { "Content-Type" => "application/json"},
+          :body => '{ "foo": 1 }'
+        })
+      end
+
+      it "returns a request hash and a response hash" do
+        expect(subject).to be_an(Array)
+        expect(subject.length).to eq(2)
+      end
+
+      describe "the returned request hash" do
+        it "returns a hash of :headers, :url, :body and :method" do
+          expect(subject[0]).to eq({
+            :url => url,
+            :method => "GET",
+            :headers => { "Content-Length" => 0 },
+            :body => nil
+          })
+        end
+      end
+
+      describe "the returned response hash" do
+        it "returns a hash of :headers, :status, :body" do
+          expect(subject[1]).to eq({
+            :status => "201",
+            :headers => { "content-type" => "application/json"},
+            :body => '{ "foo": 1 }'
+          })
+        end
+      end
+    end
+
+    describe "when the path starts with a slash" do
+      let(:path) { "/some-path/some-segment" }
+
+      it "doesn't add a double slash" do
+        stub = stub_request(:get, "https://api.cloudfoundry.com/some-path/some-segment")
+        subject
+        expect(stub).to have_been_requested
+      end
+    end
+
+    describe "when the path does not start with a slash" do
+      let(:path) { "some-path/some-segment" }
+
+      it "doesn't add a double slash" do
+        stub = stub_request(:get, "https://api.cloudfoundry.com/some-path/some-segment")
+        subject
+        expect(stub).to have_been_requested
+      end
+    end
+
+    describe 'trace' do
+      before do
+        rest_client.trace = true
+        stub_request(:get, url).to_return(:status => 200, :headers => { "content-type" => "application/json" }, :body => '{"some": "json"}')
+      end
+
+      it "prints the request and the response" do
+        mock(rest_client).print_request({:headers=>{"Content-Length"=>0}, :url=>"https://api.cloudfoundry.com/some-path", :method=>"GET", :body=>nil})
+        mock(rest_client).print_response({ :status => "200", :headers => { "content-type" => "application/json" }, :body => '{"some": "json"}' })
+        subject
+      end
+    end
+
+    describe "following redirects" do
+      before do
+        stub_request(:post, "https://api.cloudfoundry.com/apps").to_return(
+          :status => 301,
+          :headers => { "location" => "https://api.cloudfoundry.com/apps/some-guid" }
+        )
+        stub_request(:get, "https://api.cloudfoundry.com/apps/some-guid").to_return(
+          :status => 200,
+          :body => '{"some": "json"}'
+        )
+      end
+
+      it "follows redirects correctly, returning the response to the 2nd redirect" do
+        request, response = rest_client.request("POST", "apps")
+        expect(response).to eql(
+          :status => "200",
+          :headers => {},
+          :body => '{"some": "json"}'
+        )
+      end
+    end
+  end
+end

data/spec/cfoundry/trace_helpers_spec.rb

@@ -2,8 +2,14 @@ require 'spec_helper'
 
 describe CFoundry::TraceHelpers do
   let(:fake_class) { Class.new { include CFoundry::TraceHelpers } }
-  let(:request) { Net::HTTP::Get.new("http://api.cloudfoundry.com/foo", "bb-FOO" => "bar") }
-  let(:response) { Net::HTTPNotFound.new("foo", 404, "bar") }
+  let(:request) do
+    {
+      :method => "GET",
+      :url => "http://api.cloudfoundry.com/foo",
+      :headers => { "bb-foo" => "bar", "accept" => "*/*" }
+    }
+  end
+  let(:response) { { :status => 404, :body => "not found", :headers => {} } }
 
   shared_examples "request_trace tests" do
     it { should include request_trace }
@@ -12,7 +18,7 @@ describe CFoundry::TraceHelpers do
   end
 
   shared_examples "response_trace tests" do
-    before { stub(response).body { response_body } }
+    before { response[:body] = response_body }
 
     it "traces the provided response" do
       fake_class.new.response_trace(response).should == response_trace
@@ -33,7 +39,7 @@ describe CFoundry::TraceHelpers do
     context "with a request body" do
       let(:body_trace) { "REQUEST_BODY: Some body text" }
 
-      before { request.body = "Some body text" }
+      before { request[:body] = "Some body text" }
 
       include_examples "request_trace tests"
     end
@@ -53,7 +59,6 @@ describe CFoundry::TraceHelpers do
     end
 
     context "with a JSON response body" do
-
       let(:response_body) { "{\"name\": \"vcap\",\"build\": 2222,\"support\": \"http://support.cloudfoundry.com\"}" }
       let(:response_trace) { "RESPONSE: [404]\nRESPONSE_HEADERS:\n\nRESPONSE_BODY:\n#{MultiJson.dump(MultiJson.load(response_body), :pretty => true)}" }
 

data/spec/cfoundry/uaaclient_spec.rb

@@ -3,13 +3,28 @@ require "spec_helper"
 describe CFoundry::UAAClient do
   let(:target) { "https://uaa.example.com" }
   let(:uaa) { CFoundry::UAAClient.new(target) }
+  let(:auth_header) { "bearer access-token" }
+
+  before do
+    uaa.token = CFoundry::AuthToken.new(auth_header)
+  end
+
+  shared_examples "UAA wrapper" do
+    it "converts UAA errors to CFoundry equivalents" do
+      mock(uaa).wrap_uaa_errors { nil }
+      subject
+    end
+  end
 
   describe '#prompts' do
     subject { uaa.prompts }
 
+    include_examples "UAA wrapper"
+
     # GET (target)/login
     it "receives the prompts from /login" do
       stub_request(:get, "#{target}/login").to_return :status => 200,
+        :headers => {'Content-Type' => 'application/json'},
         :body => <<EOF
           {
             "timestamp": "2012-11-08T13:32:18+0000",
@@ -42,54 +57,37 @@ EOF
   describe '#authorize' do
     let(:username) { "foo@bar.com" }
     let(:password) { "test" }
+    let(:creds) { {:username => username, :password => password} }
+    let(:state) { 'somestate' }
+    let(:redirect_uri) { 'https://uaa.cloudfoundry.com/redirect/vmc' }
+    let(:auth) { Object.new }
 
-    subject { uaa.authorize(:username => username, :password => password) }
+    subject { uaa.authorize(username, password) }
 
-    it 'returns the token on successful authentication' do
-      stub_request(
-        :post,
-        "#{target}/oauth/authorize"
-      ).with(
-        :query => {
-          "client_id" => uaa.client_id,
-          "redirect_uri" => uaa.redirect_uri,
-          "response_type" => "token"
-        }
-      ).to_return(
-        :status => 302,
-        :headers => {
-          "Location" => "#{uaa.redirect_uri}#access_token=bar&token_type=foo&fizz=buzz&foo=bar"
-        }
-      )
+    before { stub(uaa).token_issuer.stub!.implicit_grant_with_creds { auth } }
+
+    include_examples "UAA wrapper"
 
-      expect(subject).to eq "foo bar"
+    it 'returns the token on successful authentication' do
+      stub(uaa).token_issuer.mock!.implicit_grant_with_creds(creds) { auth }
+      expect(subject).to eq auth
     end
 
-    it 'raises CFoundry::Denied if authentication fails' do
-      stub_request(
-        :post,
-        "#{target}/oauth/authorize"
-      ).with(
-        :query => {
-          "client_id" => uaa.client_id,
-          "redirect_uri" => uaa.redirect_uri,
-          "response_type" => "token"
-        }
-      ).to_return(
-        :status => 401,
-        :headers => {
-          "Location" => "#{uaa.redirect_uri}#access_token=bar&token_type=foo&fizz=buzz&foo=bar"
-        },
-        :body => <<EOF
-          {
-            "error": "unauthorized",
-            "error_description": "Bad credentials"
-          }
-EOF
-      )
+    context 'when authorization fails' do
+      context 'in the expected way' do
+        it 'raises a CFoundry::Denied error' do
+          stub(uaa).token_issuer.stub!.implicit_grant_with_creds { raise CF::UAA::BadResponse.new("401: FooBar") }
 
-      expect { subject }.to raise_error(
-        CFoundry::Denied, "401: Bad credentials")
+          expect { subject }.to raise_error(CFoundry::Denied, "401: Authorization failed")
+        end
+      end
+
+      context 'in an unexpected way' do
+        it 'raises a CFoundry::Denied error' do
+          stub(uaa).token_issuer.stub!.implicit_grant_with_creds { raise CF::UAA::BadResponse.new("no_status_code") }
+          expect { subject }.to raise_error(CFoundry::Denied, "400: Authorization failed")
+        end
+      end
     end
   end
 
@@ -97,10 +95,25 @@ EOF
     subject { uaa.users }
 
     it 'requests /Users' do
-      req = stub_request(:get, "#{target}/Users").to_return(
-        :body => '{ "fake_data": "123" }')
-      expect(subject).to eq({ :fake_data => "123" })
-      expect(req).to have_been_requested
+      stub_request(:get, "#{target}/Users").with(
+        :headers => { "authorization" => auth_header }
+      ).to_return(
+        :headers => {'Content-Type' => 'application/json'},
+        :body => '{ "resources": [] }'
+      )
+      expect(subject).to eq({'resources' => []})
+    end
+
+    context "when there is no token" do
+      before { uaa.token = nil }
+
+      it "doesn't blow up" do
+        stub_request(:get, "#{target}/Users").to_return(
+          :headers => {'Content-Type' => 'application/json'},
+          :body => '{ "resources": [] }'
+        )
+        expect(subject).to eq({'resources' => []})
+      end
     end
   end
 
@@ -111,30 +124,21 @@ EOF
 
     subject { uaa.change_password(guid, new, old) }
 
+    include_examples "UAA wrapper"
+
     it 'sends a password change request' do
-      req = stub_request(
-        :put,
-        "#{target}/Users/#{guid}/password"
-      ).with(
-        :body => {
-          :password => new,
-          :oldPassword => old
-        },
+      req = stub_request(:put, "#{target}/Users/#{guid}/password").with(
         :headers => {
-          "Content-Type" => "application/json",
-          "Accept" => "application/json"
+          "Content-Type" => "application/json;charset=utf-8",
+          "Accept" => "application/json;charset=utf-8",
+          "Authorization" => auth_header
         }
       ).to_return(
         :status => 200,
-        :body => <<EOF
-          {
-            "status": "ok",
-            "message": "password_updated"
-          }
-EOF
+        :headers => {'Content-Type' => 'application/json'},
+        :body => '{ "status": "ok", "message": "password_updated" }'
       )
 
-
       subject
 
       expect(req).to have_been_requested
@@ -147,21 +151,22 @@ EOF
 
     subject { uaa.password_score(password) }
 
+    include_examples "UAA wrapper"
+
     before do
-      @request = stub_request(:post, "#{target}/password/score").with(
-        :body => {:password => password, },
-        :headers => { "Accept" => "application/json" }
+      stub_request(:post, "#{target}/password/score").with(
+        :body => 'password=password',
+        :headers => {
+          'Accept' => 'application/json;charset=utf-8',
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=utf-8',
+        }
       ).to_return(
         :status => 200,
+        :headers => {'Content-Type' => 'application/json'},
         :body => response
       )
     end
 
-    it 'sends a password change request' do
-      subject
-      expect(@request).to have_been_requested
-    end
-
     context 'when the score is 0 and the required is 0' do
       let(:response) { MultiJson.encode "score" => 0, "requiredScore" => 0 }
       it { should == :good }
@@ -198,69 +203,91 @@ EOF
     end
   end
 
-  describe '#request_uri' do
-    subject { uaa.request_uri URI.parse(uaa.target + "/foo"), Net::HTTP::Get }
+  describe "#add_user" do
+    let(:email) { 'test@test.com' }
+    let(:password) { 'secret' }
+
+    subject { uaa.add_user(email, password) }
+
+    context 'with valid data' do
+      it "should add a user" do
+        req =
+          stub_request(:post, "https://uaa.example.com/Users").with(
+            :body =>
+              { :userName => email,
+                :emails => [{ :value => email }],
+                :password => password,
+                :name => { :givenName => email, :familyName => email }
+              }
+          ).to_return(
+            :status => 200,
+            :body => '{ "id" : "id" }',
+            :headers => { "Content-Type" => 'application/json' }
+          )
+
+        expect(subject).to eq({"id" => "id"})
+        expect(req).to have_been_requested
+      end
+    end
+  end
 
-    context 'when an HTTPNotFound error occurs' do
-      before {
+  describe "#wrap_uaa_errors" do
+    subject { uaa.send(:wrap_uaa_errors) { raise error } }
 
-        stub_request(:get, 'https://uaa.example.com/foo').to_return :status => 404,
-          :body => "NOT FOUND"
-      }
+    context "when the block raises CF::UAA::BadResponse" do
+      let(:error) { CF::UAA::BadResponse }
 
-      it 'raises the correct error' do
-        expect {subject}.to raise_error CFoundry::NotFound, "404: NOT FOUND"
+      it "raises CFoundry::BadResponse" do
+        expect { subject }.to raise_exception(CFoundry::BadResponse)
       end
     end
 
+    context "when the block raises CF::UAA::NotFound" do
+      let(:error) { CF::UAA::NotFound }
 
-    shared_examples "Denied tests" do
-      before {
-        stub_request(:get, 'https://uaa.example.com/foo').to_return :status => error_code,
-          :body => "{\"error_description\":\"Something detailed\"}"
-      }
-
-      it 'raises the correct error' do
-        expect {subject}.to raise_error CFoundry::Denied, "#{error_code}: Something detailed"
+      it "raises CFoundry::NotFound" do
+        expect { subject }.to raise_exception(CFoundry::NotFound)
       end
     end
 
+    context "when the block raises CF::UAA::InvalidToken" do
+      let(:error) { CF::UAA::InvalidToken }
 
-    context 'when an HTTPForbidden error occurs' do
-      let(:error_code) { 403 }
-       include_examples "Denied tests"
+      it "raises CFoundry::Denied" do
+        expect { subject }.to raise_exception(CFoundry::Denied)
+      end
     end
 
-    context 'when an HTTPUnauthorized error occurs' do
-      let(:error_code) { 401 }
-      include_examples "Denied tests"
-    end
+    context "when the block raises CF::UAA::TargetError" do
+      let(:error) { CF::UAA::TargetError.new({ "error" => "foo", "error_description" => "bar" }) }
 
-    context 'when an HTTPBadRequest error occurs' do
-      let(:error_code) { 400 }
-      include_examples "Denied tests"
+      it "raises CFoundry::UAAError" do
+        expect { subject }.to raise_exception(CFoundry::UAAError, "foo: bar")
+      end
     end
+  end
 
-    context "when an HTTPConflict error occurs" do
-      before {
-        stub_request(:get, 'https://uaa.example.com/foo').to_return :status => 409,
-          :body => "{\"message\":\"There was a conflict\"}"
-      }
+  describe "#token_issuer" do
+    it "has logging level 0 if #trace is true" do
+      uaa.trace = true
+      expect(uaa.send(:token_issuer).logger.level).to eq 0
+    end
 
-      it 'raises the correct error' do
-        expect {subject}.to raise_error CFoundry::Denied, "409: There was a conflict"
-      end
+    it "has logging level 1 if #trace is false" do
+      uaa.trace = false
+      expect(uaa.send(:token_issuer).logger.level).to eq 1
     end
+  end
 
-    context "when any other type of error occurs" do
-      before {
-        stub_request(:get, 'https://uaa.example.com/foo').to_return :status => 411,
-          :body => "NOT LONG ENOUGH"
-      }
+  describe "#scim" do
+    it "has logging level 0 if #trace is true" do
+      uaa.trace = true
+      expect(uaa.send(:scim).logger.level).to eq 0
+    end
 
-      it 'raises the correct error' do
-        expect {subject}.to raise_error CFoundry::BadResponse, "411: NOT LONG ENOUGH"
-      end
+    it "has logging level 1 if #trace is false" do
+      uaa.trace = false
+      expect(uaa.send(:scim).logger.level).to eq 1
     end
   end
 end