new_cfoundry 4.8.2

data/spec/cfoundry/baseclient_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+
+describe CFoundry::BaseClient do
+  let(:authorization_endpoint) { "http://uaa.example.com" }
+  subject(:client) { CFoundry::BaseClient.new("http://api.example.com") }
+  describe "#request" do
+    before do
+      allow(subject).to receive(:handle_response).with(anything, anything, anything)
+    end
+
+    context "when given multiple segments" do
+      it "encodes the segments and joins them with '/'" do
+        expect(subject).to receive(:request_raw).with("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
+          expect(subject).to receive(:request_raw).with("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
+          expect(subject).to receive(:request_raw).with("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
+        allow(subject).to receive(:request_raw)
+        subject.token = token
+        allow(token).to receive(: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
+            allow(subject).to receive(:refresh_token!)
+            subject.request("GET", "foo")
+          end
+
+          it "refreshes the access token" do
+            expect(subject).to receive(: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
+            expect(subject).to receive(:request_raw).with(anything, anything, anything)
+            expect(subject).not_to receive(: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
+          expect(subject).to receive(:request_raw).with(anything, anything, anything)
+          expect(subject).not_to receive(:refresh_token!)
+          subject.request("GET", "foo")
+        end
+      end
+    end
+
+    describe "#refresh_token!" do
+      let(:uaa) { double }
+      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 { allow(subject).to receive(:uaa) { uaa } }
+
+      it "refreshes the token with UAA client and assigns it" do
+        expect(uaa).to receive(: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
+      let(:info) { { :authorization_endpoint => authorization_endpoint } }
+
+      before do
+        allow(subject).to receive(:info) { info }
+      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)
+          allow(subject).to receive(:token) { token }
+          expect(subject.uaa.token).to eq token
+        end
+
+        context "with the endpoint as 'authorization_endpoint'" do
+          let(:info) { { :authorization_endpoint => "foo" } }
+
+          it "uses it to create the UAAClient" do
+            expect(subject.uaa).to be_a CFoundry::UAAClient
+            expect(subject.uaa.target).to eq "foo"
+          end
+        end
+
+        context "when proxy is set" do
+          before do
+            subject.http_proxy = 'http-proxy.example.com'
+            subject.https_proxy = 'https-proxy.example.com'
+          end
+
+          it "passes the proxy to the uaa client" do
+            allow(CFoundry::UAAClient).to receive(:new).and_call_original
+            subject.uaa
+            expect(CFoundry::UAAClient).to have_received(:new).with(anything, anything, hash_including(
+                http_proxy: 'http-proxy.example.com',
+                https_proxy: 'https-proxy.example.com'
+            ))
+          end
+        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
+        allow(subject).to receive(: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
+        allow(subject).to receive(:info) { { :authorization_endpoint => "http://uaa.example.com" } }
+      end
+
+      it "delegates to the uaa's password strength method" do
+        expect(subject.uaa).to receive(:password_score).with('password')
+        subject.password_score('password')
+      end
+    end
+
+    context "without a uaa" do
+      before do
+        allow(subject).to receive(: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 "handles https" do
+      stub_request(:get, "https://example.com/something").to_return(
+        :body => "https result")
+
+      chunks = []
+      subject.stream_url("https://example.com/something") do |chunk|
+        chunks << chunk
+      end
+
+      expect(chunks).to eq(["https result"])
+    end
+
+    it "sets proxy options if available" do
+      stub_request(:get, "https://example.com/something")
+      subject.https_proxy = "user:password@https-proxy.example.com:1234"
+      allow(Net::HTTP).to receive(:start).and_call_original
+
+      subject.stream_url("https://example.com/something")
+
+      expect(Net::HTTP).to have_received(:start).with(anything, anything, 'https-proxy.example.com', 1234, 'user', 'password', anything)
+    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 Denied 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 Unauthorized if response is 401" do
+      stub_request(:get, "http://example.com/something").to_return(
+        :status => 401, :body => "result")
+
+      expect {
+        subject.stream_url("http://example.com/something")
+      }.to raise_error(CFoundry::Unauthorized, /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
+
+  describe "#target=" do
+    let(:base_client) { CFoundry::BaseClient.new("https://api.example.com") }
+    let(:new_target) { "some-target-url.com"}
+
+    it "sets a new target" do
+      expect{base_client.target = new_target}.to change {base_client.target}.from("https://api.example.com").to(new_target)
+    end
+
+    it "sets a new target on the rest client" do
+      expect{base_client.target = new_target}.to change{base_client.rest_client.target}.from("https://api.example.com").to(new_target)
+    end
+  end
+end

data/spec/cfoundry/client_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe CFoundry::Client do
+  before do
+    allow_any_instance_of(CFoundry::V2::Client).to receive(:info)
+  end
+
+  subject { CFoundry::Client.get('http://example.com') }
+
+  it "returns a v2 client" do
+    expect(subject).to be_a(CFoundry::V2::Client)
+  end
+end

data/spec/cfoundry/errors_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe 'Errors' do
+  describe CFoundry::Timeout do
+    let(:parent) { Timeout::Error.new }
+
+    subject { CFoundry::Timeout.new("POST", '/blah', parent) }
+
+    describe '#to_s' do
+      subject { super().to_s }
+      it { should eq "POST /blah timed out" }
+    end
+
+    describe '#method' do
+      subject { super().method }
+      it { should eq "POST" }
+    end
+
+    describe '#uri' do
+      subject { super().uri }
+      it { should eq '/blah' }
+    end
+
+    describe '#parent' do
+      subject { super().parent }
+      it { should eq parent }
+    end
+  end
+
+  describe CFoundry::InvalidTarget do
+    let(:target) { "http://--foo-bar" }
+    subject { CFoundry::InvalidTarget.new(target) }
+
+    describe '#to_s' do
+      subject { super().to_s }
+      it { should eq "Invalid target URI: #{target}"}
+    end
+
+    describe '#target' do
+      subject { super().target }
+      it { should eq target }
+    end
+  end
+
+  describe CFoundry::APIError do
+    let(:request) { { :method => "GET", :url => "http://api.example.com/foo", :headers => {} } }
+    let(:response_body) { "NOT FOUND" }
+    let(:response) { { :status => 404, :headers => {}, :body => response_body } }
+
+    subject { CFoundry::APIError.new(nil, nil, request, response) }
+
+    describe '#to_s' do
+      subject { super().to_s }
+      it { should eq "404: NOT FOUND" }
+    end
+
+    describe '#request' do
+      subject { super().request }
+      it { should eq request }
+    end
+
+    describe '#response' do
+      subject { super().response }
+      it { should eq response }
+    end
+
+    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
+          expect(CFoundry::APIError.new(nil, nil, request, response).description).to eq("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
+          expect(CFoundry::APIError.new(nil, nil, request, response).description).to eq("Some plain text")
+        end
+      end
+
+      it "allows override of description" do
+        expect(CFoundry::APIError.new("My description", nil, request, response).description).to eq("My description")
+      end
+
+    end
+
+    describe "#request_trace" do
+      describe '#request_trace' do
+        subject { super().request_trace }
+        it { should include "REQUEST: " }
+      end
+    end
+
+    describe "#response_trace" do
+      describe '#response_trace' do
+        subject { super().response_trace }
+        it { should include "RESPONSE: " }
+      end
+    end
+
+    it "sets error code to response error code by default" do
+      expect(CFoundry::APIError.new(nil, nil, request, response).error_code).to eq(404)
+    end
+
+    it "allows override of error code" do
+      expect(CFoundry::APIError.new(nil, 303, request, response).error_code).to eq(303)
+    end
+
+  end
+end