cfoundry 1.5.3 → 2.0.0

data/spec/cfoundry/v2/domain_spec.rb

@@ -1,11 +1,14 @@
 require "spec_helper"
 
-describe CFoundry::V2::Domain do
-  let(:client) { fake_client }
+module CFoundry
+  module V2
+    describe Domain do
+      let(:space) { build(:space) }
+      let(:domain) { build(:domain, :spaces => [space]) }
 
-  subject { CFoundry::V2::Domain.new("domain-id-1", client) }
-
-  it "should have a spaces association" do
-    expect(subject.spaces).to eq([])
+      it "should have a spaces association" do
+        expect(domain.spaces).to eq([space])
+      end
+    end
   end
 end

data/spec/cfoundry/v2/model_magic/model_magic/attribute_spec.rb

@@ -1,119 +1,120 @@
 require "spec_helper"
 
-module CFoundry::V2
-  describe ModelMagic do
-    let(:client) { fake_client }
-    let(:mymodel) { fake_model }
-    let(:guid) { random_string("my-object-guid") }
-    let(:myobject) { mymodel.new(guid, client) }
-
-    describe 'attributes' do
-      describe 'reading' do
-        let(:mymodel) { fake_model { attribute :foo, :object } }
-
-        context 'when it exists in the manifest' do
-          subject { myobject.fake(:foo => "bar") }
-
-          it 'returns the value from the manifest' do
-            expect(subject.foo).to eq "bar"
-          end
-
-          context 'and the default is nil but the value is false' do
-            let(:mymodel) {
-              fake_model { attribute :foo, :object, :default => nil }
-            }
-
-            subject { myobject.fake(:foo => false) }
+module CFoundry
+  module V2
+    describe ModelMagic do
+      describe "attributes" do
+        let(:guid) { "test-model-guid-1" }
+        let(:client) { build(:client) }
+
+        describe "reading" do
+          context "when it exists in the manifest" do
+            let(:manifest) { {:metadata => {}, :entity => {:foo => "bar"}} }
+
+            let(:model) do
+              TestModelBuilder.build(guid, client, manifest) { attribute :foo, :object }
+            end
 
-            it 'returns false' do
-              expect(subject.foo).to eq false
+            it "returns the value from the manifest" do
+              expect(model.foo).to eq "bar"
             end
-          end
 
-          context 'and the default is false but the value is nil' do
-            let(:mymodel) {
-              fake_model { attribute :foo, :object, :default => false }
-            }
+            context "and the default is nil but the value is false" do
+              let(:model) do
+                TestModelBuilder.build(guid, client, manifest) { attribute :foo, :object, :default => nil }
+              end
 
-            subject { myobject.fake(:foo => nil) }
+              before do
+                model.foo = false
+              end
 
-            it 'returns nil' do
-              expect(subject.foo).to eq nil
+              it "returns false" do
+                expect(model.foo).to eq false
+              end
             end
-          end
-        end
 
-        context 'when the manifest has not been acquired' do
-          it 'retrieves the manifest the first time' do
-            mock(client.base).my_fake_model(guid) {
-              {:entity => {:foo => "fizz"}}
-            }.ordered
+            context "and the default is false but the value is nil" do
+              let(:model) do
+                TestModelBuilder.build(guid, client, manifest) { attribute :foo, :object, :default => false }
+              end
 
-            expect(myobject.foo).to eq "fizz"
+              before do
+                model.foo = nil
+              end
 
-            dont_allow(client.base).my_fake_model.ordered
-
-            expect(myobject.foo).to eq "fizz"
+              it "returns nil" do
+                expect(model.foo).to eq nil
+              end
+            end
           end
-        end
 
-        context 'when it does not exist in the manifest' do
-          let(:mymodel) {
-            fake_model { attribute :foo, :object, :default => "foo" }
-          }
+          context "when the manifest has not been acquired" do
+            let(:model) do
+              TestModelBuilder.build(guid, client) { attribute :foo, :object }
+            end
 
-          subject { myobject.fake }
+            it "retrieves the manifest the first time" do
+              mock(client.base).test_model("test-model-guid-1") {
+                {:entity => {:foo => "fizz"}}
+              }.ordered
 
-          it 'returns the default value' do
-            expect(subject.foo).to eq "foo"
-          end
-        end
+              expect(model.foo).to eq "fizz"
 
-        context 'when the attribute has a custom json key' do
-          let(:mymodel) {
-            fake_model { attribute :foo, :object, :at => :not_foo }
-          }
+              dont_allow(client.base).model.ordered
 
-          subject { myobject.fake }
+              expect(model.foo).to eq "fizz"
+            end
+          end
 
-          it 'retrieves the attribute using the custom key' do
-            stub(client.base).my_fake_model(guid) {
-              {:entity => {:not_foo => "fizz"}}
-            }
+          context "when it does not exist in the manifest" do
+            let(:model) do
+              TestModelBuilder.build(guid, client, {:entity => {}}) { attribute :foo, :object, :default => "foo" }
+            end
 
-            expect(myobject.foo).to eq "fizz"
+            it "returns the default value" do
+              expect(model.foo).to eq "foo"
+            end
           end
-        end
-      end
 
-      describe 'writing' do
-        context 'when the attribute has a custom json key' do
-          let(:mymodel) {
-            fake_model { attribute :foo, :object, :at => :not_foo }
-          }
+          context "when the attribute has a custom json key" do
+            let(:model) do
+              TestModelBuilder.build(guid, client) { attribute :foo, :object, :at => :not_foo }
+            end
 
-          subject { myobject }
+            before do
+              stub(client.base).test_model("test-model-guid-1") {
+                {:entity => {:not_foo => "fizz"}}
+              }
+            end
 
-          it "uses the 'at' value in the update payload" do
-            mock(client.base).put("v2", :my_fake_models, subject.guid, hash_including(:payload => {:not_foo => 123}))
-            subject.foo = 123
-            subject.update!
+            it "retrieves the attribute using the custom key" do
+              expect(model.foo).to eq "fizz"
+            end
           end
+        end
 
-          it "uses the 'at' value in the create payload" do
-            subject.foo = 123
+        describe "writing" do
+          context "when the attribute has a custom json key" do
+            let(:model) do
+              TestModelBuilder.build(guid, client) { attribute :foo, :object, :at => :not_foo }
+            end
 
-            mock(client.base).post(
-              "v2", :my_fake_models,
-              hash_including(:payload => {:not_foo => 123})
-            ) { {:metadata => {}} }
+            it "uses the 'at' value in the update payload" do
+              mock(client.base).put("v2", :test_models, model.guid, hash_including(:payload => {:not_foo => 123}))
+              model.foo = 123
+              model.update!
+            end
 
-            subject.create!
-          end
+            it "uses the 'at' value in the create payload" do
+              model.foo = 123
+              mock(client.base).post("v2", :test_models, hash_including(:payload => {:not_foo => 123})) { {:metadata => {}} }
+              model.create!
+            end
 
-          it "is then readable via the attribute name" do
-            subject.foo = 123
-            expect(subject.foo).to eq 123
+            it "is then readable via the attribute name" do
+              model.foo = 123
+              expect(model.foo).to eq 123
+            end
           end
         end
       end

data/spec/cfoundry/v2/model_magic/model_magic/has_summary_spec.rb

@@ -1,18 +1,17 @@
 require "spec_helper"
 
-module CFoundry::V2
-  describe ModelMagic do
-    let(:client) { fake_client }
-    let(:guid) { random_string("my-object-guid") }
-    let(:myobject) { mymodel.new(guid, client) }
-
-    describe 'summarization for an arbitrary model' do
-      let(:mymodel) { fake_model { attribute :foo, :string } }
-      let(:summary_attributes) { {:foo => "abcd"} }
-
-      subject { myobject }
+class TestModel < CFoundry::V2::Model
+  attribute :foo, :string
+end
 
-      it_behaves_like 'a summarizeable model'
+module CFoundry
+  module V2
+    describe ModelMagic do
+      it_behaves_like "a summarizeable model" do
+        let(:summary_attributes) { {:foo => "abcd"} }
+        let(:client) { build(:client) }
+        subject { TestModel.new("some-guid-1", client) }
+      end
     end
   end
-end
+end

data/spec/cfoundry/v2/model_magic/model_magic/to_many_spec.rb

@@ -1,59 +1,53 @@
 require "spec_helper"
 
-module CFoundry::V2
-  include ModelMagic::ToMany
-  
-  class AssociatedModel < FakeModel
-    attribute :attribute, String
-  end
-
-  describe ModelMagic::ToMany do
-    let(:client) { fake_client }
-    let(:mymodel) { fake_model }
-    let(:guid) { random_string("my-object-guid") }
-    let(:myobject) { mymodel.new(guid, client) }
-
-    describe "to_many relationships" do
-      describe "associated create" do
-        let!(:model) { fake_model { to_many :associated_models } }
-        let(:instance) { model.new(nil, client).fake }
-        let!(:create_request) { WebMock.stub_request(:post, /v2\/associated_model/).to_return(:body => {:metadata => {:guid => "thing"}}.to_json) }
-        let!(:add_request) { WebMock.stub_request(:put, /v2\/my_fake_models\/.*\/associated_models/).to_return(:body => {}.to_json) }
-
-        before do
-          stub_request(:get, /v2\/my_fake_models\/.*\/associated_models/)
-          instance.associated_models = []
-        end
-
-        it "returns a new associated object" do
-          instance.create_associated_model.should be_a(AssociatedModel)
-        end
-
-        it "sets the relation" do
-          created = instance.create_associated_model
-          instance.associated_models.should include(created)
-        end
-
-        context "with attributes for the association" do
-          it "sets these attributes on the association" do
-            created = instance.create_associated_model(:attribute => "value")
-            created.attribute.should == "value"
-          end
-        end
-
-        it "calls out to cloud_controller" do
-          instance.create_associated_model
-          create_request.should have_been_requested
-        end
-
-        context "when creation fails" do
-          let!(:create_request) { WebMock.stub_request(:post, /v2\/associated_model/).to_raise(:not_authorized) }
-
-          it "raises an exception" do
-            expect { instance.create_associated_model }.to raise_error(StandardError)
+class AssociatedModel < CFoundry::V2::Model
+  attribute :attribute, String
+end
+
+module CFoundry
+  module V2
+    module ModelMagic
+      describe ToMany do
+        let(:client) { build(:client) }
+
+        describe "to_many relationships" do
+          describe "associated create" do
+            let(:model) do
+              TestModelBuilder.build("test-model-guid-1", client) { to_many :associated_models }
+            end
+
+            before do
+              WebMock.stub_request(:put, /v2\/test_models\/.*\/associated_models/).to_return(:body => {}.to_json)
+              WebMock.stub_request(:post, /v2\/associated_model/).to_return(:body => {:metadata => {:guid => "thing"}}.to_json)
+              stub_request(:get, /v2\/test_models\/.*\/associated_models/)
+              model.associated_models = []
+            end
+
+            it "returns a new associated object" do
+              model.create_associated_model.should be_a(AssociatedModel)
+            end
+
+            it "sets the relation" do
+              created = model.create_associated_model
+              model.associated_models.should include(created)
+            end
+
+            context "with attributes for the association" do
+              it "sets these attributes on the association" do
+                created = model.create_associated_model(:attribute => "value")
+                created.attribute.should == "value"
+              end
+            end
+
+            context "when creation fails" do
+              it "raises an exception" do
+                WebMock.stub_request(:post, /v2\/associated_model/).to_raise(:not_authorized)
+                expect { model.create_associated_model }.to raise_error(StandardError)
+              end
+            end
           end
         end
       end
     end
   end
-end
+end

data/spec/cfoundry/v2/model_magic/model_magic/to_one_spec.rb

@@ -1,94 +1,103 @@
 require "spec_helper"
 
-module CFoundry::V2
-  include ModelMagic::ToOne
-  class Associated < FakeModel
-    attribute :attribute, String
-  end
-
-  describe ModelMagic::ToOne do
-    let(:client) { fake_client }
-    let(:mymodel) { fake_model }
-    let(:guid) { random_string("my-object-guid") }
-    let(:myobject) { mymodel.new(guid, client) }
-
-    describe 'to_one relationships' do
-      describe 'writing' do
-        let!(:mymodel) { fake_model { to_one :foo } }
-        let!(:othermodel) { fake_model :foo }
-
-        let(:myobject) { mymodel.new(nil, client).fake }
-        let(:otherobject) { othermodel.new(nil, client).fake }
-
-        subject { myobject.foo = otherobject }
-
-        it "sets the GUID in the manifest to the object's GUID" do
-          expect { subject }.to change {
-            myobject.manifest[:entity][:foo_guid]
-          }.to(otherobject.guid)
-        end
-
-        it "tracks internal changes in the diff" do
-          expect { subject }.to change { myobject.diff }.to(
-            :foo_guid => otherobject.guid)
-        end
-
-        it "tracks high-level changes in .changes" do
-          before = myobject.foo
-          expect { subject }.to change { myobject.changes }.to(
-            :foo => [before, otherobject])
-        end
-
-        it "returns the assigned value" do
-          myobject.send(:foo=, otherobject).should == otherobject
-        end
-
-        context "when there is a default" do
-          let(:mymodel) { fake_model { to_one :foo, :default => nil } }
-
-          subject { myobject.foo = nil }
-
-          it "allows setting to the default" do
-            myobject.foo = otherobject
-
-            expect { subject }.to change {
-              myobject.manifest[:entity][:foo_guid]
-            }.from(otherobject.guid).to(nil)
+class AssociatedModel < CFoundry::V2::Model
+  attribute :attribute, String
+end
+
+module CFoundry
+  module V2
+    module ModelMagic
+      describe ToOne do
+        let(:client) { build(:client) }
+        let(:model) { model.new("my-object-guid-1", client) }
+
+        describe "to_one relationships" do
+          describe "writing" do
+            let(:model) do
+              TestModelBuilder.build("my-model-guid-1", client) { to_one :associated_model }
+            end
+
+            let(:other_model) do
+              AssociatedModel.new("my-model-guid-2", client)
+            end
+
+            before do
+              stub_request(:get, /v2\/test_models\/.*/).to_return(:body => {:entity => {}}.to_json)
+            end
+
+            it "sets the GUID in the manifest to the object's GUID" do
+              expect {
+                model.associated_model = other_model
+              }.to change { model.manifest[:entity][:associated_model_guid] }.to(other_model.guid)
+            end
+
+            it "tracks internal changes in the diff" do
+              expect {
+                model.associated_model = other_model
+              }.to change { model.diff }.to(:associated_model_guid => other_model.guid)
+            end
+
+            it "tracks high-level changes in .changes" do
+              previous_associated_model = AssociatedModel.new("my-model-guid-3", client)
+              model.associated_model = previous_associated_model
+
+              expect {
+                model.associated_model = other_model
+              }.to change { model.changes }.to(:associated_model => [previous_associated_model, other_model])
+            end
+
+            it "returns the assigned value" do
+              model.send(:associated_model=, other_model).should == other_model
+            end
+
+            context "when there is a default" do
+              let(:model) { TestModelBuilder.build("my-model-guid-1", client) { to_one :associated_model, :default => nil } }
+
+              before do
+                model.associated_model = other_model
+              end
+
+              it "allows setting to the default" do
+                expect {
+                  model.associated_model = nil
+                }.to change {
+                  model.manifest[:entity][:associated_model_guid]
+                }.from(other_model.guid).to(nil)
+              end
+            end
           end
-        end
-      end
-
-      describe 'associated create' do
-        let!(:model) { fake_model { to_one :associated } }
-        let(:instance) { model.new(nil, client).fake }
-        let!(:request) { WebMock.stub_request(:post, /v2\/associated/).to_return(:body => {:metadata => {:guid => "thing"}}.to_json) }
-
-        it 'returns a new associated object' do
-          instance.create_associated.should be_a(Associated)
-        end
-
-        it 'sets the relation' do
-          created = instance.create_associated
-          instance.associated.should == created
-        end
-
-        context 'with attributes for the association' do
-          it 'sets these attributes on the association' do
-            created = instance.create_associated(:attribute => 'value')
-            created.attribute.should == 'value'
-          end
-        end
-
-        it 'calls out to cloud_controller' do
-          instance.create_associated
-          request.should have_been_requested
-        end
-
-        context 'when creation fails' do
-          let!(:request) { WebMock.stub_request(:post, /v2\/associated/).to_raise(:not_authorized) }
 
-          it 'raises an exception' do
-            expect { instance.create_associated }.to raise_error(StandardError)
+          describe "associated create" do
+            let(:model) do
+              TestModelBuilder.build("my-model-guid-1", client) { to_one :associated_model }
+            end
+
+            before do
+              WebMock.stub_request(:post, /v2\/associated_model/).to_return(:body => {:metadata => {:guid => "thing"}}.to_json)
+            end
+
+            it "returns a new associated object" do
+              model.create_associated_model.should be_a(AssociatedModel)
+            end
+
+            it "sets the relation" do
+              created = model.create_associated_model
+              model.associated_model.should == created
+            end
+
+            context "with attributes for the association" do
+              it "sets these attributes on the association" do
+                created = model.create_associated_model(:attribute => "value")
+                created.attribute.should == "value"
+              end
+            end
+
+            context "when creation fails" do
+              it "raises an exception" do
+                WebMock.stub_request(:post, /v2\/associated/).to_raise(:not_authorized)
+                expect { instance.create_associated }.to raise_error(StandardError)
+              end
+            end
           end
         end
       end