new_cfoundry 4.8.2

data/spec/cfoundry/v2/base_spec.rb

@@ -0,0 +1,375 @@
+require "spec_helper"
+
+describe CFoundry::V2::Base do
+  let(:target) { "https://api.example.com" }
+  let(:base) { CFoundry::V2::Base.new(target) }
+
+  describe "helper methods for HTTP verbs" do
+    let(:rest_client) { base.rest_client }
+    let(:path) { "some-path" }
+    let(:options) { { :some => :option} }
+    let(:url) { target + "/" + path }
+    let(:args) { [path, options] }
+
+    shared_examples "handling responses" do |verb|
+      context 'when successful' do
+        context 'and the accept type is JSON' do
+          let(:options) { {:accept => :json} }
+
+          it 'returns the parsed JSON' do
+            stub_request(:any, 'https://api.example.com/some-path').to_return(:status => 200, :body => "{\"hello\": \"there\"}")
+            expect(subject).to eq(:hello => "there")
+          end
+        end
+
+        context 'and the accept type is not JSON' do
+          let(:options) { {:accept => :form} }
+
+          it 'returns the body' do
+            stub_request(:any, 'https://api.example.com/some-path').to_return :status => 200, :body =>  "body"
+            expect(subject).to eq "body"
+          end
+        end
+      end
+
+      context 'when an error occurs' do
+        let(:response_code) { 404 }
+
+        it 'raises the correct error if JSON is parsed successfully' do
+          stub_request(:any, 'https://api.example.com/some-path').to_return(
+            :status => response_code,
+            :body =>  "{\"code\": 111, \"description\": \"Something bad happened\"}"
+          )
+          expect {subject}.to raise_error(CFoundry::SystemError, "111: Something bad happened")
+        end
+
+        it 'raises the correct error if code is missing from response' do
+          stub_request(:any, 'https://api.example.com/some-path').to_return(
+            :status => response_code,
+            :body =>  "{\"description\": \"Something bad happened\"}"
+          )
+          expect {subject}.to raise_error CFoundry::NotFound
+        end
+
+        it 'raises the correct error if response body is not JSON' do
+          stub_request(:any, 'https://api.example.com/some-path').to_return(
+            :status => response_code,
+            :body =>  "Error happened"
+          )
+          expect {subject}.to raise_error CFoundry::NotFound
+        end
+
+        it 'raises a generic APIError if code is not recognized' do
+          stub_request(:any, 'https://api.example.com/some-path').to_return :status => response_code,
+            :body =>  "{\"code\": 6932, \"description\": \"Something bad happened\"}"
+          expect {subject}.to raise_error CFoundry::APIError, "6932: Something bad happened"
+        end
+
+        context 'when a timeout exception occurs' do
+          before { stub_request(:any, url).to_raise(::Timeout::Error) }
+
+          it 'raises the correct error' do
+            expect { subject }.to raise_error CFoundry::Timeout, /#{url} timed out/
+          end
+        end
+
+        context 'when an HTTPNotFound error occurs' do
+          before { stub_request(:any, url).to_return(:status => 404, :body => "NOT FOUND") }
+
+          it 'raises the correct error' do
+            expect {subject}.to raise_error CFoundry::NotFound, "404: NOT FOUND"
+          end
+        end
+
+        context 'when an HTTPForbidden error occurs' do
+          before { stub_request(:any, url).to_return(:status => 403, :body => "NONE SHALL PASS") }
+
+          it 'raises the correct error' do
+            expect { subject }.to raise_error CFoundry::Denied, "403: NONE SHALL PASS"
+          end
+        end
+
+        context 'when an HTTPUnauthorized error occurs' do
+          before { stub_request(:any, url).to_return(:status => 401, :body => "YE FOO SHALL BAR") }
+
+          it 'raises the correct error' do
+            expect { subject }.to raise_error CFoundry::Unauthorized, "401: YE FOO SHALL BAR"
+          end
+        end
+
+        context "when any other type of error occurs" do
+          before { stub_request(:any, url).to_return(:status => 411, :body => "NOT LONG ENOUGH") }
+
+          it 'raises the correct error' do
+            expect { subject }.to raise_error CFoundry::BadResponse, "411: NOT LONG ENOUGH"
+          end
+        end
+
+        it 'includes the request and response hashes when it raises errors' do
+          stub_request(:any, url).to_return(:status => 411, :body => "NOT LONG ENOUGH")
+
+          begin
+            subject
+          rescue CFoundry::BadResponse => e
+            expect(e.response).to eq({
+              :status => "411",
+              :headers => {},
+              :body => "NOT LONG ENOUGH"
+            })
+            expect(e.request).to eq({
+              :headers => { "Content-Length" => 0 },
+              :method => verb,
+              :body => nil,
+              :url => "https://api.example.com/some-path"
+            })
+          end
+        end
+      end
+    end
+
+    shared_examples "normalizing arguments" do |verb|
+      context "when multiple path segments are passed" do
+        let(:segments) { ["first-segment", "next-segment"] }
+
+        context "when an options hash is not supplied" do
+          let(:args) { segments }
+
+          it "makes a request with the correct url and options" do
+            expect(rest_client).to receive(:request).with(verb, "first-segment/next-segment", {}) { [request, response] }
+            subject
+          end
+        end
+
+        context "when an options has is supplied" do
+          let(:args) { segments + [options] }
+
+          it "makes a request with the correct url and options" do
+            expect(rest_client).to receive(:request).with(verb, "first-segment/next-segment", options) { [request, response] }
+            subject
+          end
+        end
+      end
+
+      context "when a single path segment is passed" do
+        context "when an options hash is not supplied" do
+          let(:args) { ["first-segment"] }
+
+          it "makes a request with the correct url and options" do
+            expect(rest_client).to receive(:request).with(verb, "first-segment", {}) { [request, response] }
+            subject
+          end
+        end
+
+        context "when an options has is supplied" do
+          let(:args) { ["first-segment", options] }
+
+          it "makes a request with the correct url and options" do
+            expect(rest_client).to receive(:request).with(verb, "first-segment", options) { [request, response] }
+            subject
+          end
+        end
+      end
+    end
+
+    let(:response) { { :status => "201", :headers => { "some-header-key" => "some-header-value" }, :body => "some-body" } }
+    let(:request) do
+      {
+        :method => "GET",
+        :url => "http://api.example.com/some-path",
+        :headers => { "some-header-key" => "some-header-value" },
+        :body => "some-body"
+      }
+    end
+
+    describe "#get" do
+      subject { base.get(*args) }
+
+      it "makes a GET request" do
+        expect(rest_client).to receive(:request).with("GET", "some-path", options) { [request, response] }
+        subject
+      end
+
+      include_examples "handling responses", "GET"
+      include_examples "normalizing arguments", "GET"
+    end
+
+    describe "#post" do
+      subject { base.post(*args) }
+
+      it "makes a POST request" do
+        expect(rest_client).to receive(:request).with("POST", "some-path", options) { [request, response] }
+        subject
+      end
+
+      include_examples "handling responses", "POST"
+      include_examples "normalizing arguments", "POST"
+    end
+
+    describe "#put" do
+      subject { base.put(*args) }
+
+      it "makes a PUT request" do
+        expect(rest_client).to receive(:request).with("PUT", "some-path", options) { [request, response] }
+        subject
+      end
+
+      include_examples "handling responses", "PUT"
+      include_examples "normalizing arguments", "PUT"
+    end
+
+    describe "#delete" do
+      subject { base.delete(*args) }
+
+      it "makes a DELETE request" do
+        expect(rest_client).to receive(:request).with("DELETE", "some-path", options) { [request, response] }
+        subject
+      end
+
+      include_examples "handling responses", "DELETE"
+      include_examples "normalizing arguments", "DELETE"
+    end
+  end
+
+  describe "#resource_match" do
+    let(:fingerprints) { "some-fingerprints" }
+
+    it "makes a PUT request to the resource_match endpoint with the correct payload" do
+      stub = stub_request(:put, "https://api.example.com/v2/resource_match").
+        with(:body => fingerprints).
+        to_return(:body => "{}")
+      base.resource_match(fingerprints)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe "#upload_app" do
+    let(:guid) { "some-guid" }
+    let(:bits) { "some-bits" }
+    let(:job_guid) { "123abc" }
+    let(:fake_zipfile) { File.new("#{SPEC_ROOT}/fixtures/empty_file") }
+    let(:upload_response) { %Q({"metadata":{"guid":"#{job_guid}"}}) }
+
+    def stub_upload
+      stub_request(:put, "https://api.example.com/v2/apps/#{guid}/bits?async=true"
+      ).to_return(
+          :body => upload_response
+      )
+    end
+
+    def stub_poll
+      allow(base).to receive(:poll_upload_until_finished)
+    end
+
+    it "makes a PUT request to the app bits endpoint with the correct payload" do
+      upload_stub = stub_upload
+      stub_poll
+      base.upload_app(guid, fake_zipfile)
+      expect(upload_stub).to have_been_requested
+    end
+
+    context "when async is supported" do
+      it "polls the job until finished" do
+        stub_upload
+        status_stub = stub_request(:get, "https://api.example.com/v2/jobs/#{job_guid}"
+        ).to_return(
+            {:body => {:entity => {:status => 'queued'}}.to_json},
+            {:body => {:entity => {:status => 'finished'}}.to_json}
+        )
+
+        base.upload_app(guid, fake_zipfile)
+        expect(status_stub).to have_been_requested.twice
+      end
+    end
+
+    context "when async is not supported" do
+      let(:upload_response) { "" }
+
+      it "does not explode" do
+        stub_upload
+        expect {
+          base.upload_app(guid, fake_zipfile)
+        }.not_to raise_exception
+      end
+    end
+
+    context "when there is no file to upload" do
+      it "does not include 'application' in the request hash" do
+        stub_poll
+        stub =
+          stub_request(
+            :put,
+            "https://api.example.com/v2/apps/#{guid}/bits?async=true"
+          ).with { |request|
+            request.body =~ /name="resources"/ &&
+              request.body !~ /name="application"/
+          }.to_return(
+            :body => upload_response
+          )
+        base.upload_app(guid)
+        expect(stub).to have_been_requested
+      end
+    end
+  end
+
+  describe "#poll_upload_until_finished" do
+    let(:job_guid) { "123abc" }
+
+    it "makes a GET request" do
+      stub = WebMock::API.stub_request(:get, "https://api.example.com/v2/jobs/#{job_guid}"
+      ).to_return(
+        :body => %q({"metadata":{"guid":"123abc"},"entity":{"status":"running"}})
+      ).times(2).then.to_return(
+        :body => %q({"metadata":{"guid":"123abc"},"entity":{"status":"finished"}})
+      )
+      base.poll_upload_until_finished(job_guid)
+      expect(stub).to have_been_requested.times(3)
+    end
+
+    it "raises CFoundry::BadResponse if upload fails" do
+      stub = WebMock::API.stub_request(:get, "https://api.example.com/v2/jobs/#{job_guid}"
+      ).to_return(
+        :body => %q({"metadata":{"guid":"123abc"},"entity":{"status":"running"}})
+      ).times(2).then.to_return(
+        :body => %q({"metadata":{"guid":"123abc"},"entity":{"status":"failed"}})
+      )
+      expect {
+        base.poll_upload_until_finished(job_guid)
+      }.to raise_error(CFoundry::BadResponse)
+      expect(stub).to have_been_requested.times(3)
+    end
+  end
+
+  describe "#stream_file" do
+    let(:app_guid) { "1234" }
+    let(:instance_guid) { "3456" }
+    let(:api_url) { "https://api.example.com/v2/apps/#{app_guid}/instances/#{instance_guid}/files/some/path/segments" }
+    let(:file_url) { "http://api.example.com/static/path/to/some/file" }
+
+    before do
+      allow(base).to receive(:token) { CFoundry::AuthToken.new("bearer foo") }
+    end
+
+    it "follows the redirect returned by the files endpoint" do
+      stub_request(:get, api_url).to_return(
+        :status => 301,
+        :headers => { "location" => file_url },
+        :body =>  ""
+      )
+
+      request =
+        stub_request(
+          :get, file_url + "&tail"
+        ).with(
+          :headers => { "Accept" => "*/*", "Authorization" => "bearer foo" }
+        ).to_return(
+          :status => 200,
+          :body => "some body chunks"
+        )
+
+      base.stream_file(app_guid, instance_guid, "some", "path", "segments") do |body|
+        expect(request).to have_been_made
+        expect(body).to eql("some body chunks")
+      end
+    end
+  end
+end

data/spec/cfoundry/v2/client_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+module CFoundry
+  module V2
+    describe Client do
+      subject(:client) { build(:client) }
+
+      describe "#register" do
+        let(:uaa) { UAAClient.new('http://uaa.example.com') }
+        let(:email) { "test@test.com" }
+        let(:password) { "secret" }
+
+        subject { client.register(email, password) }
+
+        it "creates the user in uaa and ccng" do
+          allow(client.base).to receive(:uaa) { uaa }
+          allow(uaa).to receive(:add_user).with(email, password, {}) { {:id => "1234"} }
+
+          user = build(:user)
+          allow(client).to receive(:user) { user }
+          allow(user).to receive(:create!)
+          subject
+          expect(user.guid).to eq "1234"
+        end
+      end
+
+      describe "#current_user" do
+        subject { client.current_user }
+        before { client.token = token }
+
+        context "when there is no token" do
+          let(:token) { nil }
+          it { should eq nil }
+        end
+
+        context "when there is no access_token_data" do
+          let(:token) { AuthToken.new("bearer some-access-token", "some-refresh-token") }
+          it { should eq nil }
+        end
+
+        context "when there is access_token_data" do
+          let(:token_data) { {:user_id => "123", :email => "guy@example.com"} }
+          let(:auth_header) { Base64.encode64("{}#{MultiJson.encode(token_data)}") }
+          let(:token) do
+            CFoundry::AuthToken.new("bearer #{auth_header}", "some-refresh-token")
+          end
+
+          it { should be_a User }
+
+          describe '#guid' do
+            subject { super().guid }
+            it { should eq "123" }
+          end
+
+          describe '#emails' do
+            subject { super().emails }
+            it { should eq [{:value => "guy@example.com"}] }
+          end
+        end
+      end
+
+      describe "#version" do
+        describe '#version' do
+          subject { super().version }
+          it { should eq 2 }
+        end
+      end
+
+      describe "#login_prompts" do
+        include_examples "client login prompts"
+      end
+
+      describe "#login" do
+        include_examples "client login"
+
+        it 'sets the current organization to nil' do
+          client.current_organization = "org"
+          expect { subject }.to change { client.current_organization }.from("org").to(nil)
+        end
+
+        it 'sets the current space to nil' do
+          client.current_space = "space"
+          expect { subject }.to change { client.current_space }.from("space").to(nil)
+        end
+      end
+
+      describe "#target=" do
+        let(:new_target) { "some-target-url.com"}
+
+        it "sets a new target" do
+          expect{client.target = new_target}.to change {client.target}.from("http://api.example.com").to(new_target)
+        end
+
+        it "sets a new target on the base client" do
+          expect{client.target = new_target}.to change{client.base.target}.from("http://api.example.com").to(new_target)
+        end
+      end
+
+      describe "#service_instances" do
+        let(:client) { build(:client) }
+
+        it "includes user-provided instances" do
+          expect(client.base).to receive(:service_instances).with(hash_including(user_provided: true)).and_return([])
+          client.service_instances
+        end
+      end
+
+      describe "#make_service_instance" do
+        it "returns a UserProvidedServiceInstance when json[:type] is user_provided_service_instance" do
+          json = MultiJson.load(CcApiStub::Helper.load_fixtures(:fake_cc_user_provided_service_instance).to_json, :symbolize_keys => true)
+          instance = client.make_service_instance(json)
+          expect(instance).to be_a(CFoundry::V2::UserProvidedServiceInstance)
+
+          json = MultiJson.load(CcApiStub::Helper.load_fixtures(:fake_cc_managed_service_instance).to_json, :symbolize_keys => true)
+          instance = client.make_service_instance(json)
+          expect(instance).to be_a(CFoundry::V2::ManagedServiceInstance)
+        end
+      end
+    end
+  end
+end

data/spec/cfoundry/v2/domain_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+module CFoundry
+  module V2
+    describe Domain do
+      let(:space) { build(:space) }
+      let(:domain) { build(:domain, :spaces => [space]) }
+
+      it "should have a spaces association" do
+        expect(domain.spaces).to eq([space])
+      end
+
+      describe "#owning_organization" do
+        context "when the domain is not persisted" do
+          let(:client) { build(:client) }
+          let(:domain) { build(:domain, client: client, guid: nil)}
+          it "asdf" do
+            expect(client).not_to receive(:owning_organization)
+            expect(client).to receive(:organization)
+            domain.owning_organization
+          end
+        end
+      end
+
+      describe "validations" do
+        subject { build(:domain) }
+        it { should validate_presence_of(:name) }
+        it { should allow_value("run.pivotal.io").for(:name) }
+        it { should_not allow_value("not-a-url").for(:name) }
+        it { should validate_presence_of(:owning_organization) }
+      end
+
+      describe "#system?" do
+        let(:params) { {} }
+        let(:domain) { build(:domain, {:owning_organization => nil, client: client}.merge(params)) }
+        let(:client) { build(:client) }
+
+        context "when the domain is persisted and has no owning organization" do
+          it "returns true" do
+            expect(domain.system?).to be_true
+          end
+        end
+
+        context "when the domain is not persisted" do
+          let(:params) { {:guid => nil} }
+
+          it "returns false" do
+            expect(domain.system?).to be_false
+          end
+        end
+
+        context "when the domain has an owning org" do
+          let(:params) { {:owning_organization => org} }
+          let(:org) { build(:organization) }
+
+          it "returns false" do
+            expect(domain.system?).to be_false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cfoundry/v2/event_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+module CFoundry
+  module V2
+    describe Event do
+      let(:event) { build(:event, :app_update, changes: 'STOPPED') }
+
+      describe "#metadata" do
+        it "contains the request" do
+          expect(event.metadata[:request]).to eq('STOPPED')
+        end
+      end
+    end
+  end
+end