static 1.0.0 → 1.0.1

data/vendor/cfoundry-0.5.2/spec/cfoundry/rest_client_spec.rb

@@ -0,0 +1,281 @@
+require 'spec_helper'
+
+describe CFoundry::RestClient do
+  let(:token) { nil }
+  let(:target) { "https://api.cloudfoundry.com" }
+  let(:rest_client) { CFoundry::RestClient.new(target, token) }
+
+  describe '#request' do
+    let(:path) { "some-path" }
+    let(:url) { "#{target}/#{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
+      context "when the target refuses the connection" do
+        let(:target) { "http://localhost:2358974958" }
+
+        it "raises CFoundry::TargetRefused" do
+          stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
+          expect { subject }.to raise_error(CFoundry::TargetRefused)
+        end
+      end
+
+      context "when the target is not a HTTP(S) URI" do
+        let(:target) { "ftp://foo-bar.com" }
+
+        it "raises CFoundry::InvalidTarget" do
+          expect { subject }.to raise_error(CFoundry::InvalidTarget)
+        end
+      end
+
+      context "when the target URI is invalid" do
+        let(:target) { "@#*#^! rubby" }
+
+        it "raises CFoundry::InvalidTarget" do
+          expect { subject }.to raise_error(CFoundry::InvalidTarget)
+        end
+      end
+    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 "when the path is a full url" do
+      let(:path) { "http://example.com" }
+
+      it "requests the given url" do
+        stub = stub_request(:get, "http://example.com")
+        subject
+        expect(stub).to have_been_requested
+      end
+    end
+
+    describe "when the path is malformed" do
+      let(:path) { "#%&*$(#%&$%)" }
+
+      it "blows up" do
+        expect { subject }.to raise_error(URI::InvalidURIError)
+      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/vendor/cfoundry-0.5.2/spec/cfoundry/trace_helpers_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe CFoundry::TraceHelpers do
+  let(:fake_class) { Class.new { include CFoundry::TraceHelpers } }
+  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 }
+    it { should include header_trace }
+    it { should include body_trace }
+  end
+
+  shared_examples "response_trace tests" do
+    before { response[:body] = response_body }
+
+    it "traces the provided response" do
+      fake_class.new.response_trace(response).should == response_trace
+    end
+  end
+
+  describe "#request_trace" do
+    let(:request_trace) { "REQUEST: GET http://api.cloudfoundry.com/foo" }
+    let(:header_trace) { "REQUEST_HEADERS:\n  accept : */*\n  bb-foo : bar" }
+    let(:body_trace) { "" }
+
+    subject { fake_class.new.request_trace(request) }
+
+    context "without a request body" do
+      include_examples "request_trace tests"
+    end
+
+    context "with a request body" do
+      let(:body_trace) { "REQUEST_BODY: Some body text" }
+
+      before { request[:body] = "Some body text" }
+
+      include_examples "request_trace tests"
+    end
+
+    it "returns nil if request is nil" do
+      fake_class.new.request_trace(nil).should == nil
+    end
+  end
+
+
+  describe "#response_trace" do
+    context "with a non-JSON response body" do
+      let(:response_trace) { "RESPONSE: [404]\nRESPONSE_HEADERS:\n\nRESPONSE_BODY:\nSome body" }
+      let(:response_body) { "Some body"}
+
+      include_examples "response_trace tests"
+    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)}" }
+
+      include_examples "response_trace tests"
+    end
+
+    it "returns nil if response is nil" do
+      fake_class.new.response_trace(nil).should == nil
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/spec/cfoundry/uaaclient_spec.rb

@@ -0,0 +1,332 @@
+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)
+    CF::UAA::Util.default_logger.level = 1
+  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",
+            "commit_id": "ebbf817",
+            "app": {
+              "version": "1.2.6",
+              "artifact": "cloudfoundry-identity-uaa",
+              "description": "User Account and Authentication Service",
+              "name": "UAA"
+            },
+            "prompts": {
+              "username": [
+                "text",
+                "Email"
+              ],
+              "password": [
+                "password",
+                "Password"
+              ]
+            }
+          }
+EOF
+
+      expect(subject).to eq(
+        :username => ["text", "Email"],
+        :password => ["password", "Password"])
+    end
+  end
+
+  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 }
+    let(:issuer) { Object.new }
+
+    subject { uaa.authorize(username, password) }
+
+    before do
+      stub(issuer).owner_password_grant { auth }
+      stub(uaa).token_issuer { issuer }
+    end
+
+    include_examples "UAA wrapper"
+
+    it 'returns the token on successful authentication' do
+      mock(issuer).owner_password_grant(username, password) { auth }
+      expect(subject).to eq auth
+    end
+
+    context 'when authorization fails' do
+      context 'in the expected way' do
+        it 'raises a CFoundry::Denied error' do
+          mock(issuer).owner_password_grant(anything, anything) { raise CF::UAA::BadResponse.new("401: FooBar") }
+          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
+          mock(issuer).owner_password_grant(anything, anything) { raise CF::UAA::BadResponse.new("no_status_code") }
+          expect { subject }.to raise_error(CFoundry::Denied, "400: Authorization failed")
+        end
+      end
+
+      context "with a CF::UAA::TargetError" do
+        it "retries with implicit grant" do
+          stub(issuer).owner_password_grant { raise CF::UAA::TargetError.new("useless info") }
+          mock(issuer).implicit_grant_with_creds(:username => username, :password => password)
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe '#users' do
+    subject { uaa.users }
+
+    it 'requests /Users' do
+      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
+
+  describe '#change_password' do
+    let(:guid) { "foo-bar-baz" }
+    let(:old) { "old-pass" }
+    let(:new) { "new-pass" }
+
+    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(
+        :headers => {
+          "Content-Type" => "application/json;charset=utf-8",
+          "Accept" => "application/json;charset=utf-8",
+          "Authorization" => auth_header
+        }
+      ).to_return(
+        :status => 200,
+        :headers => {'Content-Type' => 'application/json'},
+        :body => '{ "status": "ok", "message": "password_updated" }'
+      )
+
+      subject
+
+      expect(req).to have_been_requested
+    end
+  end
+
+  describe '#password_score' do
+    let(:password) { "password" }
+    let(:response) { MultiJson.encode({}) }
+
+    subject { uaa.password_score(password) }
+
+    include_examples "UAA wrapper"
+
+    before do
+      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
+
+    context 'when the score is 0 and the required is 0' do
+      let(:response) { MultiJson.encode "score" => 0, "requiredScore" => 0 }
+      it { should == :good }
+    end
+
+    context 'when the score is less than the required score' do
+      let(:response) { MultiJson.encode "score" => 1, "requiredScore" => 5 }
+      it { should == :weak }
+    end
+
+    context 'and the score is equal to the required score' do
+      let(:response) { MultiJson.encode "score" => 5, "requiredScore" => 5 }
+      it { should == :good }
+    end
+
+    context 'and the score is greater than the required score' do
+      let(:response) { MultiJson.encode "score" => 6, "requiredScore" => 5 }
+      it { should == :good }
+    end
+
+    context 'and the score is 10' do
+      let(:response) { MultiJson.encode "score" => 10, "requiredScore" => 5 }
+      it { should == :strong }
+    end
+
+    context 'and the score is 10' do
+      let(:response) { MultiJson.encode "score" => 10, "requiredScore" => 10 }
+      it { should == :strong }
+    end
+
+    context 'and the score is invalid' do
+      let(:response) { MultiJson.encode "score" => 11, "requiredScore" => 5 }
+      it { should == :weak }
+    end
+  end
+
+  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
+
+  describe "#wrap_uaa_errors" do
+    subject { uaa.send(:wrap_uaa_errors) { raise error } }
+
+    context "when the block raises CF::UAA::BadResponse" do
+      let(:error) { CF::UAA::BadResponse }
+
+      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 }
+
+      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 }
+
+      it "raises CFoundry::Denied" do
+        expect { subject }.to raise_exception(CFoundry::Denied)
+      end
+    end
+
+    context "when the block raises CF::UAA::TargetError" do
+      let(:error) { CF::UAA::TargetError.new({ :error => "foo", :error_description => "bar" }) }
+
+      it "raises CFoundry::UAAError" do
+        expect { subject }.to raise_exception(CFoundry::UAAError, "foo: bar")
+      end
+    end
+  end
+
+  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 -1
+    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
+
+  describe "#scim" do
+    it "has logging level 0 if #trace is true" do
+      uaa.trace = true
+      expect(uaa.send(:scim).logger.level).to eq -1
+    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
+
+  describe "#try_to_refresh_token!" do
+    it "uses the refresh token to get a new access token" do
+      mock(uaa.send(:token_issuer)).refresh_token_grant(uaa.token.refresh_token) do
+        CF::UAA::TokenInfo.new(
+          :token_type => "bearer",
+          :access_token => "refreshed-token",
+          :refresh_token => "some-refresh-token")
+      end
+
+      uaa.try_to_refresh_token!
+      expect(uaa.token.auth_header).to eq "bearer refreshed-token"
+      expect(uaa.token.refresh_token).to eq "some-refresh-token"
+    end
+
+    context "when the refresh token has expired" do
+      it "returns the current token" do
+        stub(uaa.send(:token_issuer)).refresh_token_grant do
+          raise CF::UAA::TargetError.new
+        end
+
+        expect {
+          uaa.try_to_refresh_token!
+        }.to_not change { uaa.token }
+      end
+    end
+  end
+end