ncfoundry 4.9.2

data/spec/cfoundry/v2/managed_service_instance_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+module CFoundry
+  module V2
+    describe ManagedServiceInstance do
+      let(:client) { build(:client) }
+      subject { build(:service_instance, :client => client) }
+
+      describe "space" do
+        let(:space) { build(:space) }
+
+        it "has a space" do
+          subject.space = space
+          expect(subject.space).to eq(space)
+        end
+
+        context "when an invalid value is assigned" do
+          it "raises a Mismatch exception" do
+            expect {
+              subject.space = [build(:organization)]
+            }.to raise_error(CFoundry::Mismatch)
+          end
+        end
+      end
+
+      describe "service_plan" do
+        let(:service_plan) { build(:service_plan) }
+
+        it "has a service plan" do
+          subject.service_plan = service_plan
+          expect(subject.service_plan).to eq(service_plan)
+        end
+
+        context "when an invalid value is assigned" do
+          it "raises a Mismatch exception" do
+            expect {
+              subject.space = [build(:organization)]
+            }.to raise_error(CFoundry::Mismatch)
+          end
+        end
+      end
+
+      describe "fetching the service instances" do
+        let(:example_response) do
+         '{
+  "total_results": 2,
+  "total_pages": 1,
+  "prev_url": null,
+  "next_url": null,
+  "resources": [
+    {
+      "metadata": {
+        "guid": "2148b3c4-3d3d-4361-87a3-1b4bf834cdea",
+        "url": "/v2/service_instances/2148b3c4-3d3d-4361-87a3-1b4bf834cdea",
+        "created_at": "2013-07-24 00:32:23 +0000",
+        "updated_at": null
+      },
+      "entity": {
+        "type": "user_provided_service_instance",
+        "name": "user-provided-6a19d",
+        "credentials": {
+          "thing": "a"
+        },
+        "space_guid": "15ee90c2-8654-40c9-a311-ecfef8cbc921",
+        "space_url": "/v2/spaces/15ee90c2-8654-40c9-a311-ecfef8cbc921",
+        "service_bindings_url": "/v2/service_instances/2148b3c4-3d3d-4361-87a3-1b4bf834cdea/service_bindings"
+      }
+    },
+    {
+      "metadata": {
+        "guid": "746c36b0-4b5f-4e46-876a-2948804ef464",
+        "url": "/v2/service_instances/746c36b0-4b5f-4e46-876a-2948804ef464",
+        "created_at": "2013-07-24 00:32:33 +0000",
+        "updated_at": null
+      },
+      "entity": {
+        "type": "managed_service_instance",
+        "name": "rds-mysql-3991f",
+        "credentials": {
+          "name": "da2f110d519d848a1a677f8df77890cc3",
+          "hostname": "mysql-service-public.cze9ndyywtkf.us-east-1.rds.amazonaws.com",
+          "host": "mysql-service-public.cze9ndyywtkf.us-east-1.rds.amazonaws.com",
+          "port": 3306,
+          "user": "ufZEqKvAXQogC",
+          "username": "ufZEqKvAXQogC",
+          "password": "p8QGNHykcSTu2",
+          "node_id": "rds_mysql_node_10mb_0"
+        },
+        "service_plan_guid": "2c7ab67d-4354-46b5-8423-b19ef6e4b50a",
+        "space_guid": "15ee90c2-8654-40c9-a311-ecfef8cbc921",
+        "gateway_data": {
+          "plan": "10mb",
+          "version": "n/a"
+        },
+        "dashboard_url": null,
+        "space_url": "/v2/spaces/15ee90c2-8654-40c9-a311-ecfef8cbc921",
+        "service_plan_url": "/v2/service_plans/2c7ab67d-4354-46b5-8423-b19ef6e4b50a",
+        "service_bindings_url": "/v2/service_instances/746c36b0-4b5f-4e46-876a-2948804ef464/service_bindings"
+      }
+    }
+  ]
+}'
+        end
+
+        context "when there is a current org and a current space" do
+          let(:org) { build(:organization) }
+          let(:space) { build(:space, organization: org) }
+          let(:client) { build(:client, current_organization: org, current_space: space) }
+
+          it "gets both user-provided and cf-managed service instances" do
+            http_stub = stub_request(:get, "#{client.target}/v2/spaces/#{space.guid}/service_instances?inline-relations-depth=1&return_user_provided_service_instances=true").to_return(:status => 200, :body => example_response)
+            client.service_instances
+            expect(http_stub).to have_been_requested
+          end
+
+          describe "via service_instance_from" do
+            it "defaults to true when user_provided is set to a bogus value (not true or false)" do
+              http_stub = stub_request(:get, "#{client.target}/v2/spaces/#{space.guid}/service_instances?inline-relations-depth=1&return_user_provided_service_instances=true").to_return(:status => 200, :body => example_response)
+              client.service_instances(user_provided: 'some_non-boolean_value')
+              expect(http_stub).to have_been_requested
+            end
+          end
+        end
+      end
+
+      describe 'query params' do
+        it 'allows query by name' do
+          expect(client).to respond_to(:service_instance_by_name)
+        end
+
+        it 'allows query by space_guid' do
+          expect(client).to respond_to(:service_instance_by_space_guid)
+        end
+
+        it 'allows query by gateway_name' do
+          expect(client).to respond_to(:service_instance_by_gateway_name)
+        end
+
+        it 'allows query by service_plan_guid' do
+          expect(client).to respond_to(:service_instance_by_service_plan_guid)
+        end
+
+        it 'allows query by service_binding_guid' do
+          expect(client).to respond_to(:service_instance_by_service_binding_guid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+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 the value from the manifest" do
+              expect(model.foo).to eq "bar"
+            end
+
+            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
+
+              before do
+                model.foo = false
+              end
+
+              it "returns false" do
+                expect(model.foo).to eq false
+              end
+            end
+
+            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
+
+              before do
+                model.foo = nil
+              end
+
+              it "returns nil" do
+                expect(model.foo).to eq nil
+              end
+            end
+          end
+
+          context "when the manifest has not been acquired" do
+            let(:model) do
+              TestModelBuilder.build(guid, client) { attribute :foo, :object }
+            end
+
+            it "retrieves the manifest the first time" do
+              expect(client.base).to receive(:test_model).with("test-model-guid-1") {
+                {:entity => {:foo => "fizz"}}
+              }.ordered
+
+              expect(model.foo).to eq "fizz"
+
+              expect(client.base).not_to receive(:model)
+
+              expect(model.foo).to eq "fizz"
+            end
+          end
+
+          context "when it does not exist in the manifest" do
+            let(:model) do
+              TestModelBuilder.build(guid, client, {:entity => {}}) { attribute :foo, :object, :default => "foo" }
+            end
+
+            it "returns the default value" do
+              expect(model.foo).to eq "foo"
+            end
+          end
+
+          context "when the attribute has a custom json key" do
+            let(:model) do
+              TestModelBuilder.build(guid, client) { attribute :foo, :object, :at => :not_foo }
+            end
+
+            before do
+              allow(client.base).to receive(:test_model).with("test-model-guid-1") {
+                {:entity => {:not_foo => "fizz"}}
+              }
+            end
+
+            it "retrieves the attribute using the custom key" do
+              expect(model.foo).to eq "fizz"
+            end
+          end
+        end
+
+        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
+
+            it "uses the 'at' value in the update payload" do
+              expect(client.base).to receive(:put).with("v2", :test_models, model.guid, hash_including(:payload => {:not_foo => 123}))
+              model.foo = 123
+              model.update!
+            end
+
+            it "uses the 'at' value in the create payload" do
+              model.foo = 123
+              expect(client.base).to receive(:post).with("v2", :test_models, hash_including(:payload => {:not_foo => 123})) { {:metadata => {}} }
+              model.create!
+            end
+
+            it "is then readable via the attribute name" do
+              model.foo = 123
+              expect(model.foo).to eq 123
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+class TestModel < CFoundry::V2::Model
+  attribute :foo, :string
+end
+
+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

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+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
+              expect(model.create_associated_model).to be_a(AssociatedModel)
+            end
+
+            it "sets the relation" do
+              created = model.create_associated_model
+              expect(model.associated_models).to 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")
+                expect(created.attribute).to eq("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

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

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+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
+              expect(model.send(:associated_model=, other_model)).to eq(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
+
+          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
+              expect(model.create_associated_model).to be_a(AssociatedModel)
+            end
+
+            it "sets the relation" do
+              created = model.create_associated_model
+              expect(model.associated_model).to eq(created)
+            end
+
+            context "with attributes for the association" do
+              it "sets these attributes on the association" do
+                created = model.create_associated_model(:attribute => "value")
+                expect(created.attribute).to eq("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
+    end
+  end
+end

data/spec/cfoundry/v2/model_magic_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module CFoundry
+  module V2
+    describe ModelMagic do
+      describe "params_from" do
+        describe "query" do
+          it "filters by a single key and value" do
+            params = ModelMagic.params_from({query: ['key', 'value']})
+            expect(params[:q]).to eq("key:value")
+          end
+
+          it "filters by a list of values for a key" do
+            params = ModelMagic.params_from({query: {key: ['value1', 'value2']}})
+            expect(params[:q]).to eq("key IN value1,value2")
+          end
+
+          it "filters by complex QueryValue" do
+            params = ModelMagic.params_from({query: {key: ModelMagic::QueryValue.new(comparator: '>', value:'value1')}})
+            expect(params[:q]).to eq("key>value1")
+          end
+
+          it "filters by multiple fields" do
+            params = ModelMagic.params_from({query: {key1: ModelMagic::QueryValue.new(comparator: '>=', value:'value1'), key2: 'value2', key3: ['value3a', 'value3b']}})
+            expect(params[:q]).to eq("key1>=value1;key2:value2;key3 IN value3a,value3b")
+          end
+
+          it "filters by multiple QueryValues" do
+            params = ModelMagic.params_from({query: {key: ModelMagic::QueryMultiValue.new({comparator: '>', value: 'value1'},{comparator: '<', value: 'value2'})}})
+            expect(params[:q]).to eq("key>value1;key<value2")
+          end
+        end
+
+        describe "other arguments" do
+          it "appends them to the params as is" do
+            params = ModelMagic.params_from({other_argument: 'something'})
+            expect(params[:other_argument]).to eq('something')
+          end
+        end
+      end
+    end
+  end
+end