ncfoundry 4.9.2

data/spec/cc_api_stub/space_users_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'net/http'
+require 'uri'
+
+describe CcApiStub::SpaceUsers do
+  let(:url) { "http://example.com/v2/spaces/123/users/94087" }
+
+  describe ".succeed_to_delete" do
+    subject { CcApiStub::SpaceUsers.succeed_to_delete }
+
+    it_behaves_like "a stubbed delete request"
+
+    context "when the :roles option is provided" do
+      let(:roles) { [:developer, :managers, :auditor] }
+      it "deletes the user from each specified role" do
+        CcApiStub::SpaceUsers.succeed_to_delete(roles: roles)
+        roles.each do |role|
+          url = "http://example.com/v2/spaces/123/#{role.to_s.pluralize}/94087"
+          uri = URI.parse(url)
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            request = Net::HTTP::Delete.new(url)
+            response = http.request(request)
+            check_response(response, code: 200, ignore_response: true)
+          end
+        end
+      end
+    end
+  end
+
+  describe ".fail_to_delete" do
+    subject { CcApiStub::SpaceUsers.fail_to_delete }
+
+    it_behaves_like "a stubbed delete request", :code => 500, :ignore_response => true
+  end
+end

data/spec/cc_api_stub/spaces_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'net/http'
+require 'uri'
+
+describe CcApiStub::Spaces do
+  describe ".succeed_to_load" do
+    let(:url) { "http://example.com/v2/spaces/234" }
+    subject { CcApiStub::Spaces.succeed_to_load }
+
+    it_behaves_like "a stubbed get request"
+  end
+
+  describe ".succeed_to_create" do
+    let(:url) { "http://example.com/v2/spaces" }
+    subject { CcApiStub::Spaces.succeed_to_create }
+
+    it_behaves_like "a stubbed post request"
+  end
+
+  describe ".summary_fixture" do
+    it "returns a space fixture" do
+      expect(CcApiStub::Spaces.summary_fixture).to be_a(Hash)
+    end
+  end
+
+  describe ".succeed_to_load_summary" do
+    let(:url) { "http://example.com/v2/spaces/234/summary" }
+    subject { CcApiStub::Spaces.succeed_to_load_summary }
+
+    it_behaves_like "a stubbed get request"
+
+    context "when specifying no_services" do
+      subject { CcApiStub::Spaces.succeed_to_load_summary(:no_services => true) }
+
+      it_behaves_like "a stubbed get request", :including_json => {"services" => []}
+    end
+  end
+end

data/spec/cc_api_stub/users_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'net/http'
+require 'uri'
+
+describe CcApiStub::Users do
+  describe ".succeed_to_load" do
+    let(:url) { "http://example.com/v2/users/2345?inline-relations-depth=2" }
+    let(:options) { {} }
+    subject { CcApiStub::Users.succeed_to_load(options) }
+
+    it_behaves_like "a stubbed get request"
+
+    context "when setting a user id" do
+      let(:options) { { :id => "some-id" } }
+
+      it_behaves_like "a stubbed get request", :including_json => { "metadata" => { "guid" => "some-id" } }
+    end
+
+    context "when setting an organization_id" do
+      let(:options) { { :organization_id => "some-id" } }
+
+      it_behaves_like "a stubbed get request", :including_json => Proc.new { |json|
+        json["entity"]["organizations"][0]["metadata"]["guid"].should == "some-id"
+      }
+    end
+
+    context "when specifying no_spaces" do
+      let(:options) { { :no_spaces => true } }
+
+      it_behaves_like "a stubbed get request", :including_json => Proc.new { |json|
+        json["entity"]["organizations"][0]["entity"]["spaces"].should == []
+      }
+    end
+
+    context "when specifying custom permissions" do
+      let(:options) { { :permissions => [:space_manager, :space2_auditor] } }
+
+      it_behaves_like "a stubbed get request", :including_json => {
+        "entity" =>
+          {
+            "managed_spaces" => [{"metadata" => { "guid" => "space-id-1" }, "entity" => {}}],
+            "audited_spaces" => [{"metadata" => { "guid" => "space-id-2" }, "entity" => {}}]
+          }
+      }
+    end
+  end
+
+  describe ".fail_to_find" do
+    let(:url) { "http://example.com/v2/users/2345" }
+    subject { CcApiStub::Users.fail_to_find }
+
+    it_behaves_like "a stubbed get request", :code => 404
+  end
+
+  describe ".succeed_to_create" do
+    let(:url) { "http://example.com/v2/users" }
+    subject { CcApiStub::Users.succeed_to_create }
+
+    it_behaves_like "a stubbed post request"
+  end
+
+  describe ".fail_to_create" do
+    let(:url) { "http://example.com/v2/users" }
+    subject { CcApiStub::Users.fail_to_create }
+
+    it_behaves_like "a stubbed post request", :code => 500
+  end
+
+  describe ".succeed_to_replace_permissions" do
+    let(:url) { "http://example.com/v2/users/123" }
+    subject { CcApiStub::Users.succeed_to_replace_permissions }
+
+    it_behaves_like "a stubbed put request", :ignore_response => true
+  end
+
+  describe ".fail_to_replace_permissions" do
+    let(:url) { "http://example.com/v2/users/123" }
+    subject { CcApiStub::Users.fail_to_replace_permissions }
+
+    it_behaves_like "a stubbed put request", :ignore_response => true, :code => 500
+  end
+
+  describe ".organizations_fixture" do
+    subject { CcApiStub::Users.organizations_fixture }
+
+    it "returns a fixture" do
+      expect(subject).to be_a Array
+    end
+  end
+
+  describe ".organizations_fixture_hash" do
+    subject { CcApiStub::Users.organization_fixture_hash }
+
+    it "returns a fixture" do
+      expect(subject).to be_a Hash
+    end
+
+    context "when specifying options" do
+      subject { CcApiStub::Users.organization_fixture_hash(:no_spaces => true, :no_managers => true) }
+
+      it "takes options into account" do
+        expect(subject[:entity][:spaces]).to be_nil
+        expect(subject[:entity][:managers]).to be_nil
+      end
+    end
+  end
+end

data/spec/cfoundry/auth_token_spec.rb

@@ -0,0 +1,153 @@
+require "base64"
+require "spec_helper"
+
+describe CFoundry::AuthToken do
+  describe ".from_uaa_token_info" do
+    let(:access_token) { JWT.encode({user_id: "a6", email: "a@b.com"}, nil, 'none') }
+    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
+      describe '#auth_header' do
+        subject { super().auth_header }
+        it { should eq "bearer #{access_token}" }
+      end
+    end
+
+    describe "#to_hash" do
+      let(:result_hash) do
+        {
+          :token => "bearer #{access_token}",
+          :refresh_token => "some-refresh-token"
+        }
+      end
+
+      describe '#to_hash' do
+        subject { super().to_hash }
+        it { should eq result_hash }
+      end
+    end
+
+    describe "#token_data" do
+      context "when the access token is encoded as expected" do
+        describe '#token_data' do
+          subject { super().token_data }
+          it { should eq({ :user_id => "a6", :email => "a@b.com"}) }
+        end
+      end
+
+      context "when the access token is not encoded as expected" do
+        let(:access_token) { Base64.encode64('random-bytes') }
+
+        describe '#token_data' do
+          subject { super().token_data }
+          it { should eq({}) }
+        end
+      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') }
+
+        describe '#token_data' do
+          subject { super().token_data }
+          it { should eq({}) }
+        end
+      end
+
+      context "when the auth header is nil" do
+        before do
+          subject.auth_header = nil
+        end
+
+        describe '#token_data' do
+          it { subject.token_data.should eq({}) }
+        end
+      end
+    end
+  end
+
+  describe ".from_hash(hash)" do
+    let(:token_data) { {baz:"buzz"} }
+    let(:token) { JWT.encode(token_data, nil, 'none') }
+
+    let(:hash) do
+      {
+        :token => "bearer #{token}",
+        :refresh_token => "some-refresh-token"
+      }
+    end
+
+    subject { CFoundry::AuthToken.from_hash(hash) }
+
+    describe "#auth_header" do
+      describe '#auth_header' do
+        subject { super().auth_header }
+        it { should eq("bearer #{token}") }
+      end
+    end
+
+    describe "#to_hash" do
+      describe '#to_hash' do
+        subject { super().to_hash }
+        it { should eq(hash) }
+      end
+    end
+
+    describe "#token_data" do
+      describe '#token_data' do
+        subject { super().token_data }
+        it { should eq({ :baz => "buzz" }) }
+      end
+    end
+  end
+
+  describe "#auth_header=" do
+    let(:access_token) { JWT.encode({ user_id: "a6", email: "a@b.com" }, nil, 'none') }
+    let(:other_access_token) { JWT.encode({ user_id: "b6", email: "a@b.com"}, nil, 'none') }
+
+    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) { JWT.encode({ exp: expiration.to_i }, nil, 'none') }
+
+    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_truthy
+        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_falsey
+        end
+      end
+    end
+  end
+end

data/spec/cfoundry/baseclient_spec.rb

@@ -0,0 +1,284 @@
+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
+      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")
+      original_proxy_env = ENV["https_proxy"]
+      ENV["https_proxy"] = "http://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)
+      ENV["https_proxy"] = original_proxy_env
+    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