static 1.0.0 → 1.0.1

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

@@ -0,0 +1,125 @@
+require "base64"
+require "spec_helper"
+
+describe CFoundry::AuthToken do
+  describe ".from_uaa_token_info" do
+    let(:access_token) { Base64.encode64('{"algo": "h1234"}{"user_id": "a6", "email": "a@b.com"}random-bytes') }
+    let(:info_hash) do
+      {
+        :token_type => "bearer",
+        :access_token => access_token,
+        :refresh_token => "some-refresh-token"
+      }
+    end
+
+
+    let(:token_info) { CF::UAA::TokenInfo.new(info_hash) }
+
+    subject { CFoundry::AuthToken.from_uaa_token_info(token_info) }
+
+    describe "#auth_header" do
+      its(:auth_header) { should eq "bearer #{access_token}" }
+    end
+
+    describe "#to_hash" do
+      let(:result_hash) do
+        {
+          :token => "bearer #{access_token}",
+          :refresh_token => "some-refresh-token"
+        }
+      end
+
+      its(:to_hash) { should eq result_hash }
+    end
+
+    describe "#token_data" do
+      context "when the access token is encoded as expected" do
+        its(:token_data) { should eq({ :user_id => "a6", :email => "a@b.com"}) }
+      end
+
+      context "when the access token is not encoded as expected" do
+        let(:access_token) { Base64.encode64('random-bytes') }
+        its(:token_data) { should eq({}) }
+      end
+
+      context "when the access token contains invalid json" do
+        let(:access_token) { Base64.encode64('{"algo": "h1234"}{"user_id", "a6", "email": "a@b.com"}random-bytes') }
+        its(:token_data) { should eq({}) }
+      end
+
+      context "when the auth header is nil" do
+        before do
+          subject.auth_header = nil
+        end
+
+        its(:token_data) { should eq({}) }
+      end
+    end
+  end
+
+  describe ".from_hash(hash)" do
+    let(:token_data) { '{"baz":"buzz"}' }
+    let(:token) { Base64.encode64("{\"foo\":1}#{token_data}") }
+
+    let(:hash) do
+      {
+        :token => "bearer #{token}",
+        :refresh_token => "some-refresh-token"
+      }
+    end
+
+    subject { CFoundry::AuthToken.from_hash(hash) }
+
+    describe "#auth_header" do
+      its(:auth_header) { should eq("bearer #{token}") }
+    end
+
+    describe "#to_hash" do
+      its(:to_hash) { should eq(hash) }
+    end
+
+    describe "#token_data" do
+      its(:token_data) { should eq({ :baz => "buzz" }) }
+    end
+  end
+
+  describe "#auth_header=" do
+    let(:access_token) { Base64.encode64('{"algo": "h1234"}{"user_id": "a6", "email": "a@b.com"}random-bytes') }
+    let(:other_access_token) { Base64.encode64('{"algo": "h1234"}{"user_id": "b6", "email": "a@b.com"}random-bytes') }
+
+    subject { CFoundry::AuthToken.new("bearer #{access_token}") }
+
+    it "invalidates @token_data" do
+      subject.token_data
+      expect {
+        subject.auth_header = "bearer #{other_access_token}"
+      }.to change { subject.token_data[:user_id] }.from("a6").to("b6")
+    end
+  end
+
+  describe "#expires_soon?" do
+    let(:access_token) { Base64.encode64(%Q|{"algo": "h1234"}{"exp":#{expiration.to_i}}random-bytes|) }
+
+    subject { CFoundry::AuthToken.new("bearer #{access_token}") }
+
+    context "when the token expires in less than 1 minute" do
+      let(:expiration) { Time.now + 59 }
+
+      it "returns true" do
+        Timecop.freeze do
+          expect(subject.expires_soon?).to be_true
+        end
+      end
+    end
+
+    context "when the token expires in greater than or equal to 1 minute" do
+      let(:expiration) { Time.now + 60 }
+
+      it "returns false" do
+        Timecop.freeze do
+          expect(subject.expires_soon?).to be_false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe CFoundry::BaseClient do
+  describe "#request" do
+    before do
+      stub(subject).handle_response(anything, anything, anything)
+    end
+
+    context "when given multiple segments" do
+      it "encodes the segments and joins them with '/'" do
+        mock(subject).request_raw("GET", "foo/bar%2Fbaz", {})
+        subject.request("GET", "foo", "bar/baz")
+      end
+    end
+
+    context "when the first segment starts with a '/'" do
+      context "and there's only one segment" do
+        it "requests with the segment unaltered" do
+          mock(subject).request_raw("GET", "/v2/apps", {})
+          subject.request("GET", "/v2/apps")
+        end
+      end
+
+      context "and there's more than one segment" do
+        it "encodes the segments and joins them with '/'" do
+          mock(subject).request_raw("GET", "%2Ffoo/bar%2Fbaz", {})
+          subject.request("GET", "/foo", "bar/baz")
+        end
+      end
+    end
+
+    context "when there is a token with an auth_header" do
+      let(:refresh_token) { nil }
+      let(:token) { CFoundry::AuthToken.new("bearer something", refresh_token) }
+
+      before do
+        stub(subject).request_raw
+        subject.token = token
+        stub(token).expires_soon? { expires_soon? }
+      end
+
+      context "and the token is about to expire" do
+        let(:uaa) { Object.new }
+        let(:expires_soon?) { true }
+
+        context "and there is a refresh token" do
+          let(:refresh_token) { "some-refresh-token" }
+
+          it "sets the token's auth header to nil to prevent recursion" do
+            stub(subject).refresh_token!
+            subject.request("GET", "foo")
+          end
+
+          it "refreshes the access token" do
+            mock(subject).refresh_token!
+            subject.request("GET", "foo")
+          end
+        end
+
+        context "and there is NOT a refresh token" do
+          let(:refresh_token) { nil }
+
+          it "moves along" do
+            mock(subject).request_raw(anything, anything, anything)
+            dont_allow(subject).refresh_token!
+            subject.request("GET", "foo")
+          end
+        end
+      end
+
+      context "and the token is NOT about to expire" do
+        let(:expires_soon?) { nil }
+
+        it "moves along" do
+          mock(subject).request_raw(anything, anything, anything)
+          dont_allow(subject).refresh_token!
+          subject.request("GET", "foo")
+        end
+      end
+    end
+
+    describe "#refresh_token!" do
+      let(:uaa) { stub }
+      let(:access_token) { Base64.encode64(%Q|{"algo": "h1234"}{"a":"b"}random-bytes|) }
+      let(:refresh_token) { "xyz" }
+      let(:new_access_token) { Base64.encode64(%Q|{"algo": "h1234"}{"a":"x"}random-bytes|) }
+      let(:auth_token) { CFoundry::AuthToken.new("bearer #{access_token}", refresh_token) }
+
+      before { stub(subject).uaa { uaa } }
+
+      it "refreshes the token with UAA client and assigns it" do
+        mock(uaa).try_to_refresh_token! {
+          CFoundry::AuthToken.new("bearer #{new_access_token}", auth_token.refresh_token)
+        }
+
+        subject.refresh_token!
+
+        expect(subject.token.auth_header).to eq "bearer #{new_access_token}"
+      end
+    end
+
+  end
+
+  describe "UAAClient" do
+    context "with a valid uaa endpoint" do
+      before do
+        stub(subject).info { { :authorization_endpoint => "http://uaa.example.com" } }
+      end
+
+      describe "#uaa" do
+        it "creates a UAAClient on the first call" do
+          expect(subject.uaa).to be_a CFoundry::UAAClient
+        end
+
+        it "returns the same object on later calls" do
+          uaa = subject.uaa
+          expect(subject.uaa).to eq uaa
+        end
+
+        it "has the same AuthToken as BaseClient" do
+          token = CFoundry::AuthToken.new(nil)
+          stub(subject).token { token }
+          expect(subject.uaa.token).to eq token
+        end
+      end
+
+      describe "#token=" do
+        it "propagates the change to #uaa" do
+          subject.uaa
+          expect(subject.uaa.token).to eq subject.token
+          subject.token = CFoundry::AuthToken.new(nil)
+          expect(subject.uaa.token).to eq subject.token
+        end
+      end
+
+      describe "#trace=" do
+        it "propagates the change to #uaa" do
+          subject.uaa
+          subject.trace = true
+          expect(subject.uaa.trace).to eq true
+          subject.trace = false
+          expect(subject.uaa.trace).to eq false
+        end
+      end
+    end
+
+    context "with no uaa endpoint" do
+      before do
+        stub(subject).info { { :something => "else" } }
+      end
+
+      describe "#uaa" do
+        it "does not return a UAAClient" do
+          expect(subject.uaa).to be_nil
+        end
+      end
+
+    end
+  end
+
+  describe "#password_score" do
+    context "with a uaa" do
+      before do
+        stub(subject).info { { :authorization_endpoint => "http://uaa.example.com" } }
+      end
+
+      it "delegates to the uaa's password strength method" do
+        mock(subject.uaa).password_score('password')
+        subject.password_score('password')
+      end
+    end
+
+    context "without a uaa" do
+      before do
+        stub(subject).info { { :something => "else" } }
+      end
+
+      it "returns :unknown" do
+        expect(subject.password_score('password')).to eq(:unknown)
+      end
+    end
+  end
+
+  describe "#stream_url" do
+    it "handles a chunked response by yielding chunks as they come in" do
+      stub_request(:get, "http://example.com/something").to_return(
+        :headers => { "Transfer-Encoding" => "chunked" },
+        :body => "result")
+
+      chunks = []
+      subject.stream_url("http://example.com/something") do |chunk|
+        chunks << chunk
+      end
+
+      expect(chunks).to eq(["result"])
+    end
+
+    it "raises NotFound if response is 404" do
+      stub_request(:get, "http://example.com/something").to_return(
+        :status => 404, :body => "result")
+
+      expect {
+        subject.stream_url("http://example.com/something")
+      }.to raise_error(CFoundry::NotFound, /result/)
+    end
+
+    it "raises NotFound if response is 403" do
+      stub_request(:get, "http://example.com/something").to_return(
+        :status => 403, :body => "result")
+
+      expect {
+        subject.stream_url("http://example.com/something")
+      }.to raise_error(CFoundry::Denied, /result/)
+    end
+
+    it "raises BadRespones if response is unexpected" do
+      stub_request(:get, "http://example.com/something").to_return(
+        :status => 344, :body => "result")
+
+      expect {
+        subject.stream_url("http://example.com/something")
+      }.to raise_error(CFoundry::BadResponse, /result/)
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe CFoundry::Client do
+  subject { CFoundry::Client.new('http://example.com') }
+
+  it "returns a v1 client when used on a v1 target" do
+    stub_request(:get, "http://example.com/info").to_return(:status => 200, :body => '{"version":1}')
+    subject.should be_a(CFoundry::V1::Client)
+  end
+
+  it "returns a v2 client when used on a v2 target" do
+    stub_request(:get, "http://example.com/info").to_return(:status => 200, :body => '{"version":2}')
+    subject.should be_a(CFoundry::V2::Client)
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe 'Errors' do
+  describe CFoundry::Timeout do
+    let(:parent) { Timeout::Error.new }
+
+    subject { CFoundry::Timeout.new("POST", '/blah', parent) }
+
+    its(:to_s) { should eq "POST /blah timed out" }
+    its(:method) { should eq "POST" }
+    its(:uri) { should eq '/blah' }
+    its(:parent) { should eq parent }
+  end
+
+  describe CFoundry::InvalidTarget do
+    let(:target) { "http://--foo-bar" }
+    subject { CFoundry::InvalidTarget.new(target) }
+
+    its(:to_s) { should eq "Invalid target URI: #{target}"}
+    its(:target) { should eq target }
+  end
+
+  describe CFoundry::APIError do
+    let(:request) { { :method => "GET", :url => "http://api.cloudfoundry.com/foo", :headers => {} } }
+    let(:response_body) { "NOT FOUND" }
+    let(:response) { { :status => 404, :headers => {}, :body => response_body } }
+
+    subject { CFoundry::APIError.new(nil, nil, request, response) }
+
+    its(:to_s) { should eq "404: NOT FOUND" }
+
+    its(:request) { should eq request }
+
+    its(:response) { should eq response }
+
+    describe "#initialize" do
+
+      context "Response body is JSON" do
+
+        let(:response_body) { "{\"description\":\"Something went wrong\"}"}
+
+        it "sets description to description field in parsed JSON" do
+          CFoundry::APIError.new(nil, nil, request, response).description.should == "Something went wrong"
+        end
+      end
+
+
+      context "Response body is not JSON" do
+
+        let(:response_body) { "Some plain text"}
+
+        it "sets description to body text" do
+          CFoundry::APIError.new(nil, nil, request, response).description.should == "Some plain text"
+        end
+      end
+
+      it "allows override of description" do
+        CFoundry::APIError.new("My description", nil, request, response).description.should == "My description"
+      end
+
+    end
+
+    describe "#request_trace" do
+      its(:request_trace) { should include "REQUEST: " }
+    end
+
+    describe "#response_trace" do
+      its(:response_trace) { should include "RESPONSE: " }
+    end
+
+    it "sets error code to response error code by default" do
+      CFoundry::APIError.new(nil, nil, request, response).error_code.should == 404
+    end
+
+    it "allows override of error code" do
+      CFoundry::APIError.new(nil, 303, request, response).error_code.should == 303
+    end
+
+  end
+end