static 1.0.0 → 1.0.1

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

@@ -0,0 +1,174 @@
+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
+      FileUtils.rm_rf tmpdir
+
+      stub(Dir).tmpdir do
+        FileUtils.mkdir_p tmpdir
+        tmpdir
+      end
+
+      stub(base).upload_app.with_any_args
+    end
+
+    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
+
+    context 'when all files match existing resources' do
+      context 'and there are directories' do
+        let(:path) { "#{SPEC_ROOT}/fixtures/apps/with_nested_directories" }
+
+        it 'prunes them before zipping' do
+          stub(fake_model).make_fingerprints(anything) do
+            [[], CFoundry::UploadHelpers::RESOURCE_CHECK_LIMIT + 1]
+          end
+
+          stub(base).resource_match(anything) do
+            %w{ xyz foo/bar/baz/fizz }.map do |path|
+              { :fn => "#{tmpdir}/.vmc_#{guid}_files/#{path}" }
+            end
+          end
+
+          mock(base).upload_app(anything, false, anything)
+
+          fake_model.upload(path)
+        end
+      end
+    end
+
+    context "when only dotfiles don't match existing resources" do
+      let(:path) { "#{SPEC_ROOT}/fixtures/apps/with_dotfiles" }
+
+      it 'does not prune them' do
+        stub(fake_model).make_fingerprints(anything) do
+          [[], CFoundry::UploadHelpers::RESOURCE_CHECK_LIMIT + 1]
+        end
+
+        stub(base).resource_match(anything) do
+          %w{ xyz }.map do |path|
+            { :fn => "#{tmpdir}/.vmc_#{guid}_files/#{path}" }
+          end
+        end
+
+        mock(base).upload_app(anything, anything, anything) do |_, zip, _|
+          expect(zip).to be_a(String)
+        end
+
+        fake_model.upload(path)
+      end
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/spec/cfoundry/v1/base_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe CFoundry::V1::Base do
+  let(:base) { CFoundry::V1::Base.new("https://api.cloudfoundry.com") }
+
+  describe '#get' do
+    let(:options) { {} }
+    subject { base.get("foo", options) }
+
+    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 => 201, :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(:get, 'https://api.cloudfoundry.com/foo').to_return :status => 201, :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(: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"
+      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
+      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
+      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"
+      end
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/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/vendor/cfoundry-0.5.2/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/vendor/cfoundry-0.5.2/spec/cfoundry/v2/app_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+
+describe CFoundry::V2::App do
+  let(:client) { fake_client }
+
+  describe "environment" do
+    let(:app) { fake :app, :env => { "FOO" => "1" } }
+
+    it "returns a hash-like object" do
+      expect(app.env["FOO"]).to eq "1"
+    end
+
+    describe "converting keys and values to strings" do
+      let(:app) { fake :app, :env => { :FOO => 1 } }
+
+      it "converts keys and values to strings" do
+        expect(app.env.to_hash).to eq("FOO" => "1")
+      end
+    end
+
+    context "when changes are made to the hash-like object" do
+      it "reflects the changes in .env" do
+        expect {
+          app.env["BAR"] = "2"
+        }.to change { app.env.to_hash }.from("FOO" => "1").to("FOO" => "1", "BAR" => "2")
+      end
+    end
+
+    context "when the env is set to something else" do
+      it "reflects the changes in .env" do
+        expect {
+          app.env = { "BAR" => "2" }
+        }.to change { app.env.to_hash }.from("FOO" => "1").to("BAR" => "2")
+      end
+    end
+  end
+
+  describe "#summarize!" do
+    let(:app) { fake :app }
+
+    it "assigns :instances as #total_instances" do
+      stub(app).summary { { :instances => 4 } }
+
+      app.summarize!
+
+      expect(app.total_instances).to eq(4)
+    end
+  end
+
+  shared_examples_for "something may stage the app" do
+    subject { fake :app, :client => client }
+    let(:response) { { :body => '{ "foo": "bar" }' } }
+
+    before do
+      stub(client.base).put("v2", "apps", subject.guid, anything) do
+        response
+      end
+    end
+
+    context "when asynchronous is true" do
+      it "sends the PUT request with &stage_async=true" do
+        mock(client.base).put(
+            "v2", "apps", subject.guid,
+            hash_including(
+              :params => { :stage_async => true },
+              :return_response => true )) do
+          response
+        end
+
+        update(true)
+      end
+
+      context "and a block is given" do
+        let(:response) do
+          { :headers => { "x-app-staging-log" => "http://app/staging/log" },
+            :body => "{}"
+          }
+        end
+
+        it "yields the URL for the logs" do
+          yielded_url = nil
+          update(true) do |url|
+            yielded_url = url
+          end
+
+          expect(yielded_url).to eq "http://app/staging/log"
+        end
+      end
+    end
+
+    context "when asynchronous is false" do
+      it "sends the PUT request with &stage_async=false" do
+        mock(client.base).put(
+            "v2", "apps", subject.guid,
+            hash_including(:params => { :stage_async => false})) do
+          response
+        end
+
+        update(false)
+      end
+    end
+  end
+
+  describe "#start!" do
+    it_should_behave_like "something may stage the app" do
+      def update(async, &blk)
+        subject.start!(async, &blk)
+      end
+    end
+  end
+
+  describe "#restart!" do
+    it_should_behave_like "something may stage the app" do
+      def update(async, &blk)
+        subject.restart!(async, &blk)
+      end
+    end
+  end
+
+  describe "#update!" do
+    describe "changes" do
+      subject { fake :app, :client => client }
+      let(:response) { { :body => '{ "foo": "bar" }' } }
+
+      before do
+        stub(client.base).put("v2", "apps", subject.guid, anything) do
+          response
+        end
+      end
+
+      it "applies the changes from the response JSON" do
+        expect {
+          subject.update!
+        }.to change { subject.manifest }.to(:foo => "bar")
+      end
+    end
+
+    it_should_behave_like "something may stage the app" do
+      def update(async, &blk)
+        subject.update!(async, &blk)
+      end
+    end
+  end
+end