cfoundry 0.4.21 → 0.5.0

data/spec/cfoundry/upload_helpers_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe CFoundry::UploadHelpers do
+  describe '#upload' do
+    let(:base) { Object.new }
+    let(:guid) { "123" }
+    let(:path) { "#{SPEC_ROOT}/fixtures/apps/with_vmcignore" }
+    let(:check_resources) { false }
+    let(:tmpdir) { "#{SPEC_ROOT}/tmp/fake_tmpdir" }
+
+    let(:client) do
+      client = Object.new
+      stub(client).base { base }
+      client
+    end
+
+    let(:fake_model) do
+      class FakeModel
+        include CFoundry::UploadHelpers
+
+        def initialize(client, guid)
+          @client = client
+          @guid = guid
+        end
+      end
+
+      FakeModel.new(client, guid)
+    end
+
+    before do
+      stub(Dir).tmpdir do
+        FileUtils.mkdir_p tmpdir
+        tmpdir
+      end
+      stub(base).upload_app.with_any_args
+    end
+
+    after { FileUtils.rm_rf tmpdir }
+
+    subject { fake_model.upload(path, check_resources) }
+
+    def relative_glob(dir)
+      base_pathname = Pathname.new(dir)
+      Dir["#{dir}/**/{*,.[^\.]*}"].map do |file|
+        Pathname.new(file).relative_path_from(base_pathname).to_s
+      end
+    end
+
+    def mock_zip(*args, &block)
+      if args.empty?
+        mock(CFoundry::Zip).pack.with_any_args(&block)
+      else
+        mock(CFoundry::Zip).pack(*args, &block)
+      end
+    end
+
+    it 'zips the app and uploads the zip file' do
+      zip_path = "#{tmpdir}/#{guid}.zip"
+      mock_zip(anything, zip_path) { true }
+      mock(base).upload_app(guid, zip_path, [])
+      subject
+    end
+
+    it 'uploads an app with the right guid' do
+      mock_zip
+      mock(base).upload_app(guid, anything, anything)
+      subject
+    end
+
+    it 'uses a unique directory name when it copies the app' do
+      mock_zip(/#{tmpdir}.*#{guid}.*/, anything)
+      subject
+    end
+
+    it 'cleans up after itself correctly' do
+      subject
+      expect(relative_glob(tmpdir)).to be_empty
+    end
+
+    it 'includes the source files of the app in the zip file' do
+      mock_zip do |src, _|
+        files = relative_glob(src)
+        expect(files).to include "non_ignored_dir"
+        expect(files).to include "non_ignored_file.txt"
+        expect(files).to include "non_ignored_dir/file_in_non_ignored_dir.txt"
+      end
+      subject
+    end
+
+    it 'includes hidden files (though stager ignores them currently)' do
+      mock_zip do |src, _|
+        expect(relative_glob(src)).to include ".hidden_file"
+      end
+      subject
+    end
+
+    it 'does not include files and directories specified in the vmcignore (including glob patterns)' do
+      mock_zip do |src, _|
+        files = relative_glob(src)
+        expect(files).not_to include "ignored_dir"
+        expect(files).not_to include "ignored_file.txt"
+        expect(files).not_to include "non_ignored_dir/ignored_file.txt" # glob pattern **/ignored_file.txt
+      end
+      subject
+    end
+
+    %w(.git _darcs .svn).each do |source_control_dir_name|
+      context "when there is a #{source_control_dir_name} directory in the app" do
+        before { FileUtils.mkdir_p("#{path}/#{source_control_dir_name}") }
+
+        it "ignores that directory" do
+          mock_zip do |src, _|
+            expect(relative_glob(src)).not_to include source_control_dir_name
+          end
+          subject
+        end
+      end
+    end
+
+    context 'when there are no files to zip' do
+      before { mock_zip { false } }
+
+      it 'passes `false` to #upload_app' do
+        mock(base).upload_app(guid, false, [])
+        subject
+      end
+    end
+  end
+end

data/spec/cfoundry/v1/base_spec.rb

@@ -3,9 +3,9 @@ require "spec_helper"
 describe CFoundry::V1::Base do
   let(:base) { CFoundry::V1::Base.new("https://api.cloudfoundry.com") }
 
-  describe '#request_uri' do
+  describe '#get' do
     let(:options) { {} }
-    subject { base.request_uri URI.parse(base.target + "/foo"), Net::HTTP::Get, options }
+    subject { base.get("foo", options) }
 
     context 'when successful' do
       context 'and the accept type is JSON' do

data/spec/cfoundry/v1/client_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe CFoundry::V1::Client do
+  let(:client) { CFoundry::V1::Client.new }
+
+  describe "#version" do
+    its(:version) { should eq 1 }
+  end
+
+  describe "#login" do
+    include_examples "client login"
+  end
+
+  describe "#login_prompts" do
+    include_examples "client login prompts"
+  end
+end

data/spec/cfoundry/v1/model_magic_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe CFoundry::V1::ModelMagic do
+  let(:client) { v1_fake_client }
+  let(:mymodel) { v1_fake_model }
+  let(:guid) { random_string("my-object-guid") }
+  let(:myobject) { mymodel.new(guid, client) }
+
+  describe "#read_manifest" do
+    context "with an attribute with different read/write locations" do
+      let(:mymodel) do
+        v1_fake_model do
+          attribute :foo, :string, :read => :x, :write => [:y, :z]
+        end
+      end
+
+      before do
+        stub(client.base).my_fake_model { { :x => "abc" } }
+      end
+
+      it "reads from the write location" do
+        expect {
+          myobject.foo = "def"
+        }.to change { myobject.read_manifest[:foo] }.from("abc").to("def")
+      end
+    end
+  end
+
+  describe "#write_manifest" do
+    context "with a read-only attribute" do
+      let(:mymodel) do
+        v1_fake_model do
+          attribute :foo, :string, :read_only => true
+        end
+      end
+
+      it "does not include the attribute" do
+        myobject.fake(:foo => "bar")
+        expect(myobject.write_manifest).to_not include :foo
+      end
+    end
+  end
+end

data/spec/cfoundry/v2/base_spec.rb

@@ -1,58 +1,281 @@
 require "spec_helper"
 
 describe CFoundry::V2::Base do
-  let(:base) { CFoundry::V2::Base.new("https://api.cloudfoundry.com") }
+  let(:target) { "https://api.cloudfoundry.com" }
+  let(:base) { CFoundry::V2::Base.new(target) }
 
-  describe '#request_uri' do
-    let(:options) { {} }
-    subject { base.request_uri URI.parse(base.target + "/foo"), Net::HTTP::Get, options }
+  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] }
 
-    context 'when successful' do
-      context 'and the accept type is JSON' do
-        let(:options) { {:accept => :json} }
+    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(:get, 'https://api.cloudfoundry.com/foo').to_return :status => 200, :body => "{\"hello\": \"there\"}"
-          expect(subject).to eq(:hello => "there")
+          it 'returns the parsed JSON' do
+            stub_request(:any, 'https://api.cloudfoundry.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.cloudfoundry.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.cloudfoundry.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.cloudfoundry.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.cloudfoundry.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.cloudfoundry.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 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.cloudfoundry.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
+            mock(rest_client).request(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
+            mock(rest_client).request(verb, "first-segment/next-segment", options) { [request, response] }
+            subject
+          end
         end
       end
 
-      context 'and the accept type is not JSON' do
-        let(:options) { {:accept => :form} }
+      context "when a single path segment is passed" do
+        context "when an options hash is not supplied" do
+          let(:args) { ["first-segment"] }
 
-        it 'returns the body' do
-          stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => 200, :body =>  "body"
-          expect(subject).to eq "body"
+          it "makes a request with the correct url and options" do
+            mock(rest_client).request(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
+            mock(rest_client).request(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.cloudfoundry.com/some-path",
+        :headers => { "some-header-key" => "some-header-value" },
+        :body => "some-body"
+      }
     end
 
-    context 'when an error occurs' do
-      let(:response_code) { 404 }
+    describe "#get" do
+      subject { base.get(*args) }
 
-      it 'raises the correct error if JSON is parsed successfully' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"code\": 111, \"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::SystemError, "111: Something bad happened"
+      it "makes a GET request" do
+        mock(rest_client).request("GET", "some-path", options) { [request, response] }
+        subject
       end
 
-      it 'raises the correct error if code is missing from response' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::NotFound
+      include_examples "handling responses", "GET"
+      include_examples "normalizing arguments", "GET"
+    end
+
+    describe "#post" do
+      subject { base.post(*args) }
+
+      it "makes a POST request" do
+        mock(rest_client).request("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
+        mock(rest_client).request("PUT", "some-path", options) { [request, response] }
+        subject
       end
 
-      it 'raises the correct error if response body is not JSON' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "Error happened"
-        expect {subject}.to raise_error CFoundry::NotFound
+      include_examples "handling responses", "PUT"
+      include_examples "normalizing arguments", "PUT"
+    end
+
+    describe "#delete" do
+      subject { base.delete(*args) }
+
+      it "makes a DELETE request" do
+        mock(rest_client).request("DELETE", "some-path", options) { [request, response] }
+        subject
       end
 
-      it 'raises a generic APIError if code is not recognized' do
-        stub_request(:get, 'https://api.cloudfoundry.com/foo').to_return :status => response_code,
-          :body =>  "{\"code\": 6932, \"description\": \"Something bad happened\"}"
-        expect {subject}.to raise_error CFoundry::APIError, "6932: Something bad happened"
+      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.cloudfoundry.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(:fake_zipfile) { File.new("#{SPEC_ROOT}/fixtures/empty_file") }
+
+    it "makes a PUT request to the app bits endpoint with the correct payload" do
+      stub = stub_request(:put, "https://api.cloudfoundry.com/v2/apps/#{guid}/bits").to_return(:body => "{}")
+      base.upload_app(guid, fake_zipfile)
+      expect(stub).to have_been_requested
+    end
+  end
+
+  describe "#stream_file" do
+    let(:app_guid) { "1234" }
+    let(:instance_guid) { "3456" }
+    let(:api_url) { "https://api.cloudfoundry.com/v2/apps/#{app_guid}/instances/#{instance_guid}/files/some/path/segments" }
+    let(:file_url) { "http://api.cloudfoundry.com/static/path/to/some/file" }
+
+    before do
+      stub(base).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