cfoundry 1.5.3 → 2.0.0

data/spec/cfoundry/v2/app_spec.rb

@@ -1,249 +1,256 @@
 require "spec_helper"
 
-describe CFoundry::V2::App do
-  let(:client) { fake_client }
+module CFoundry
+  module V2
+    describe App do
+      let(:client) { build(:client) }
 
-  subject { described_class.new("app-1", client) }
+      subject { build(:app, :client => client) }
 
-  describe "#events" do
-    let(:events) { [fake(:app_event)] }
+      describe "#events" do
+        let(:events) { [build(:app_event)] }
 
-    it "has events" do
-      subject.events = events
-      expect(subject.events).to eq(events)
-    end
+        it "has events" do
+          subject.events = events
+          expect(subject.events).to eq(events)
+        end
 
-    context "when an invalid value is assigned" do
-      it "raises a Mismatch exception" do
-        expect {
-          subject.events = [fake(:organization)]
-        }.to raise_error(CFoundry::Mismatch)
+        context "when an invalid value is assigned" do
+          it "raises a Mismatch exception" do
+            expect {
+              subject.events = [build(:organization)]
+            }.to raise_error(CFoundry::Mismatch)
+          end
+        end
       end
-    end
-  end
 
-  describe "environment" do
-    let(:app) { fake :app, :env => { "FOO" => "1" } }
+      describe "environment" do
+        let(:app) { build(:app, :env => {"FOO" => "1"}) }
 
-    it "returns a hash-like object" do
-      expect(app.env["FOO"]).to eq "1"
-    end
+        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 } }
+        describe "converting keys and values to strings" do
+          let(:app) { build(:app, :env => {:FOO => 1}) }
 
-      it "converts keys and values to strings" do
-        expect(app.env.to_hash).to eq("FOO" => "1")
-      end
-    end
+          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 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")
+        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
-    end
-  end
 
-  describe "#summarize!" do
-    let(:app) { fake :app }
+      describe "#summarize!" do
+        let(:app) { build(:app) }
 
-    it "assigns :instances as #total_instances" do
-      stub(app).summary { { :instances => 4 } }
+        it "assigns :instances as #total_instances" do
+          stub(app).summary { {:instances => 4} }
 
-      app.summarize!
+          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
+          expect(app.total_instances).to eq(4)
+        end
       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
+      shared_examples_for "something may stage the app" do
+        subject { build(:app, :client => client) }
+        let(:response) { {:body => '{ "foo": "bar" }'} }
+
+        before do
+          stub(client.base).put("v2", "apps", subject.guid, anything) do
+            response
+          end
         end
 
-        update(true)
-      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 => "{}"
-          }
+          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
 
-        it "yields the URL for the logs" do
-          yielded_url = nil
-          update(true) do |url|
-            yielded_url = url
-          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
 
-          expect(yielded_url).to eq "http://app/staging/log"
+            update(false)
+          end
         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
+      describe "#start!" do
+        it_should_behave_like "something may stage the app" do
+          def update(async, &blk)
+            subject.start!(async, &blk)
+          end
         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)
+      describe "#restart!" do
+        it_should_behave_like "something may stage the app" do
+          def update(async, &blk)
+            subject.restart!(async, &blk)
+          end
+        end
       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 { build(:app, :client => client) }
+          let(:response) { {:body => { "foo" => "bar" }.to_json } }
 
-  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
 
-      before do
-        stub(client.base).put("v2", "apps", subject.guid, anything) do
-          response
+          it "applies the changes from the response JSON" do
+            expect {
+              subject.update!
+            }.to change { subject.manifest }.to(:foo => "bar")
+          end
         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)
+        it_should_behave_like "something may stage the app" do
+          def update(async, &blk)
+            subject.update!(async, &blk)
+          end
+        end
       end
-    end
-  end
 
-  describe "#stream_update_log" do
-    let(:client) { fake_client }
-    let(:base_url) { "http://example.com/log" }
+      describe "#stream_update_log" do
+        let(:base_url) { "http://example.com/log" }
 
-    subject { described_class.new(nil, client) }
+        def mock_log(url = anything)
+          mock(client).stream_url(url) do |_, blk|
+            blk.call(yield)
+          end.ordered
+        end
 
-    def mock_log(url = anything)
-      mock(client).stream_url(url) do |_, blk|
-        blk.call(yield)
-      end.ordered
-    end
+        def stub_log(url = anything)
+          stub(client).stream_url(url) do |_, blk|
+            blk.call(yield)
+          end.ordered
+        end
 
-    def stub_log(url = anything)
-      stub(client).stream_url(url) do |_, blk|
-        blk.call(yield)
-      end.ordered
-    end
+        it "yields chunks from the response to the block" do
+          mock_log { "a" }
+          mock_log { "b" }
+          mock_log { raise CFoundry::NotFound }
 
-    it "yields chunks from the response to the block" do
-      mock_log { "a" }
-      mock_log { "b" }
-      mock_log { raise CFoundry::NotFound }
+          chunks = []
+          subject.stream_update_log(base_url) do |chunk|
+            chunks << chunk
+          end
 
-      chunks = []
-      subject.stream_update_log(base_url) do |chunk|
-        chunks << chunk
-      end
+          expect(chunks).to eq(%w(a b))
+        end
 
-      expect(chunks).to eq(%w(a b))
-    end
+        it "retries when the connection times out" do
+          mock_log { raise ::Timeout::Error }
+          mock_log { "a" }
+          mock_log { raise ::Timeout::Error }
+          mock_log { "b" }
+          mock_log { raise ::Timeout::Error }
+          mock_log { raise CFoundry::NotFound }
+
+          chunks = []
+          subject.stream_update_log(base_url) do |chunk|
+            chunks << chunk
+          end
 
-    it "retries when the connection times out" do
-      mock_log { raise Timeout::Error }
-      mock_log { "a" }
-      mock_log { raise Timeout::Error }
-      mock_log { "b" }
-      mock_log { raise Timeout::Error }
-      mock_log { raise CFoundry::NotFound }
-
-      chunks = []
-      subject.stream_update_log(base_url) do |chunk|
-        chunks << chunk
-      end
+          expect(chunks).to eq(%w(a b))
+        end
 
-      expect(chunks).to eq(%w(a b))
-    end
+        it "tracks the offset to stream from" do
+          url = "#{base_url}&tail&tail_offset="
 
-    it "tracks the offset to stream from" do
-      url = "#{base_url}&tail&tail_offset="
+          mock_log("#{url}0") { "a" }
+          mock_log("#{url}1") { raise ::Timeout::Error }
+          mock_log("#{url}1") { "b" }
+          mock_log("#{url}2") { raise CFoundry::NotFound }
 
-      mock_log("#{url}0") { "a" }
-      mock_log("#{url}1") { raise Timeout::Error }
-      mock_log("#{url}1") { "b" }
-      mock_log("#{url}2") { raise CFoundry::NotFound }
+          chunks = []
+          subject.stream_update_log(base_url) do |chunk|
+            chunks << chunk
+          end
 
-      chunks = []
-      subject.stream_update_log(base_url) do |chunk|
-        chunks << chunk
-      end
+          expect(chunks).to eq(%w(a b))
+        end
 
-      expect(chunks).to eq(%w(a b))
-    end
+        it "stops when the endpoint disappears" do
+          mock_log { "a" }
+          mock_log { "b" }
+          mock_log { raise CFoundry::NotFound }
+          stub_log { "c" }
 
-    it "stops when the endpoint disappears" do
-      mock_log { "a" }
-      mock_log { "b" }
-      mock_log { raise CFoundry::NotFound }
-      stub_log { "c" }
+          chunks = []
+          subject.stream_update_log(base_url) do |chunk|
+            chunks << chunk
+          end
 
-      chunks = []
-      subject.stream_update_log(base_url) do |chunk|
-        chunks << chunk
+          expect(chunks).to eq(%w(a b))
+        end
       end
 
-      expect(chunks).to eq(%w(a b))
-    end
-  end
+      describe "delete!" do
+        it "defaults to recursive" do
+          mock(client.base).delete("v2", :apps, subject.guid, {:params => {:recursive => true}})
 
-  describe "delete!" do
-    it "defaults to recursive" do
-      mock(client.base).delete("v2", :apps, subject.guid, {:params => {:recursive => true}})
+          subject.delete!
+        end
+      end
 
-      subject.delete!
+      it "accepts and ignores an options hash" do
+        mock(client.base).delete("v2", :apps, subject.guid, {:params => {:recursive => true}})
+
+        subject.delete!(:recursive => false)
+      end
     end
   end
 end

data/spec/cfoundry/v2/client_spec.rb

@@ -1,73 +1,77 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CFoundry::V2::Client do
-  let(:client) { CFoundry::V2::Client.new }
+module CFoundry
+  module V2
+    describe Client do
+      let(:client) { build(:client) }
 
-  describe "#register" do
-    let(:uaa) { CFoundry::UAAClient.new }
-    let(:email) { 'test@test.com' }
-    let(:password) { 'secret' }
+      describe "#register" do
+        let(:uaa) { UAAClient.new }
+        let(:email) { "test@test.com" }
+        let(:password) { "secret" }
 
-    subject { client.register(email, password) }
+        subject { client.register(email, password) }
 
-    it "creates the user in uaa and ccng" do
-      stub(client.base).uaa { uaa }
-      stub(uaa).add_user(email, password) { { "id" => "1234" } }
+        it "creates the user in uaa and ccng" do
+          stub(client.base).uaa { uaa }
+          stub(uaa).add_user(email, password) { {"id" => "1234"} }
 
-      user = fake(:user)
-      stub(client).user { user }
-      stub(user).create!
-      subject
-      expect(user.guid).to eq "1234"
-    end
-  end
+          user = build(:user)
+          stub(client).user { user }
+          stub(user).create!
+          subject
+          expect(user.guid).to eq "1234"
+        end
+      end
 
-  describe "#current_user" do
-    subject { client.current_user }
-    before { client.token = token }
+      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 token" do
+          let(:token) { nil }
+          it { should eq nil }
+        end
 
-    context "when there is no access_token_data" do
-      let(:token) { CFoundry::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
+        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
 
-      it { should be_a CFoundry::V2::User }
-      its(:guid) { should eq "123" }
-      its(:emails) { should eq [{ :value => "guy@example.com"}] }
-    end
-  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
 
-  describe "#version" do
-    its(:version) { should eq 2 }
-  end
+          it { should be_a User }
+          its(:guid) { should eq "123" }
+          its(:emails) { should eq [{:value => "guy@example.com"}] }
+        end
+      end
 
-  describe "#login_prompts" do
-    include_examples "client login prompts"
-  end
+      describe "#version" do
+        its(:version) { should eq 2 }
+      end
 
-  describe "#login" do
-    include_examples "client login" do
-      it 'sets the current organization to nil' do
-        client.current_organization = "org"
-        expect { subject }.to change { client.current_organization }.from("org").to(nil)
+      describe "#login_prompts" do
+        include_examples "client login prompts"
       end
 
-      it 'sets the current space to nil' do
-        client.current_space = "space"
-        expect { subject }.to change { client.current_space }.from("space").to(nil)
+      describe "#login" do
+        include_examples "client login" do
+          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
       end
     end
   end
-end
+end