cfoundry 1.5.3 → 2.0.0

data/spec/cfoundry/v2/organization_spec.rb

@@ -1,30 +1,28 @@
 require "spec_helper"
 
-describe CFoundry::V2::Organization do
-  let(:client) { fake_client }
+module CFoundry
+  module V2
+    describe Organization do
+      let(:client) { build(:client) }
+      let(:organization) { build(:organization, :client => client) }
 
-  subject { CFoundry::V2::Organization.new("organization-1", client) }
+      it_behaves_like "a summarizeable model" do
+        subject { organization }
+        let(:summary_attributes) { {:name => "fizzbuzz"} }
+      end
 
-  describe "summarization" do
-    let(:mymodel) { CFoundry::V2::Organization }
-    let(:myobject) { fake(:organization) }
-    let(:summary_attributes) { { :name => "fizzbuzz" } }
+      it "has quota_definition" do
+        quota = build(:quota_definition)
+        organization.quota_definition = quota
+        expect(organization.quota_definition).to eq(quota)
+      end
 
-    subject { myobject }
-
-    it_behaves_like "a summarizeable model"
-  end
-
-  it "has quota_definition" do
-    quota = fake(:quota_definition)
-    subject.quota_definition = quota
-    expect(subject.quota_definition).to eq(quota)
-  end
-
-  it "has billing_enabled" do
-    [true, false].each do |v|
-      subject.billing_enabled = v
-      expect(subject.billing_enabled).to eq(v)
+      it "has billing_enabled" do
+        [true, false].each do |v|
+          organization.billing_enabled = v
+          expect(organization.billing_enabled).to eq(v)
+        end
+      end
     end
   end
 end

data/spec/cfoundry/v2/quota_definition_spec.rb

@@ -1,52 +1,50 @@
 require "spec_helper"
 
-describe CFoundry::V2::QuotaDefinition do
-  let(:client) { fake_client }
-
-  subject { CFoundry::V2::QuotaDefinition.new("quota-definition-1", client) }
-
-  it "has guid" do
-    expect(subject.guid).to eq("quota-definition-1")
-  end
-
-  it "has name" do
-    subject.name = "name"
-    expect(subject.name).to eq("name")
-  end
-
-  it "has non_basic_services_allowed" do
-    [true, false].each do |v|
-      subject.non_basic_services_allowed = v
-      expect(subject.non_basic_services_allowed).to eq(v)
-    end
-  end
-
-  it "has total_services" do
-    [0, 1].each do |v|
-      subject.total_services = v
-      expect(subject.total_services).to eq(v)
-    end
-  end
-
-  it "has total_services" do
-    [0, 1].each do |v|
-      subject.total_services = v
-      expect(subject.total_services).to eq(v)
-    end
-  end
-
-  describe "querying" do
-    let(:foo) { fake(:quota_definition, :name => "foo") }
-    let(:bar) { fake(:quota_definition, :name => "bar") }
-    let(:baz) { fake(:quota_definition, :name => "baz") }
-
-    let(:quota_definitions) { [foo, bar, baz] }
-
-    let(:client) { fake_client :quota_definitions => quota_definitions }
-
-    it "is queryable by name" do
-      quota = quota_definitions.last
-      expect(client.quota_definition_by_name("bar")).to eq(bar)
+module CFoundry
+  module V2
+    describe QuotaDefinition do
+      let(:quota_definition) { build(:quota_definition) }
+
+      it "has guid" do
+        quota_definition.guid = "quota-definition-1"
+        expect(quota_definition.guid).to eq("quota-definition-1")
+      end
+
+      it "has name" do
+        quota_definition.name = "name"
+        expect(quota_definition.name).to eq("name")
+      end
+
+      it "has non_basic_services_allowed" do
+        [true, false].each do |v|
+          quota_definition.non_basic_services_allowed = v
+          expect(quota_definition.non_basic_services_allowed).to eq(v)
+        end
+      end
+
+      it "has total_services" do
+        [0, 1].each do |v|
+          quota_definition.total_services = v
+          expect(quota_definition.total_services).to eq(v)
+        end
+      end
+
+      it "has total_services" do
+        [0, 1].each do |v|
+          quota_definition.total_services = v
+          expect(quota_definition.total_services).to eq(v)
+        end
+      end
+
+      describe "querying" do
+        let(:client) { build(:client) }
+
+        it "is queryable by name" do
+          mock(client).quota_definitions({:query=>[:name, "quota-name"]}) {[]}
+
+          client.quota_definition_by_name("quota-name")
+        end
+      end
     end
   end
 end

data/spec/cfoundry/v2/route_spec.rb

@@ -1,38 +1,41 @@
 # encoding: UTF-8
-require 'spec_helper'
+require "spec_helper"
 
-module CFoundry::V2
-  describe Route do
-    subject { Route.new(nil, fake_client) }
+module CFoundry
+  module V2
+    describe Route do
+      let(:route) { build(:route) }
+      subject { route }
 
-    describe "validations" do
-      it { should validate_presence_of(:domain) }
-      it { should validate_presence_of(:space) }
+      describe "validations" do
+        it { should validate_presence_of(:domain) }
+        it { should validate_presence_of(:space) }
 
-      # http://tools.ietf.org/html/rfc1035
-      it "only allows host names according to RFC1035" do
-        message = "can only include a-z, 0-9 and -"
+        # http://tools.ietf.org/html/rfc1035
+        it "only allows host names according to RFC1035" do
+          message = "can only include a-z, 0-9 and -"
 
-        subject.should allow_value("a", "starts-with-letter", "includes-9-digits", "ends-with-letter",
-          "ends-with-digit-9", "can--have--consecutive---dashes", "allows-UPPERCASE-chars").for(:host)
+          route.should allow_value("a", "starts-with-letter", "includes-9-digits", "ends-with-letter",
+            "ends-with-digit-9", "can--have--consecutive---dashes", "allows-UPPERCASE-chars").for(:host)
 
-        ["-must-start-with-letter", "9must-start-with-letter", "must-not-end-with-dash-", "must-not-include-punctuation-chars-@\#$%^&*()",
-          "must-not-include-special-chars-ä", "must.not.include.dots"].each do |bad_value|
-          subject.should_not allow_value(bad_value).for(:host).with_message(message)
-        end
+          ["-must-start-with-letter", "9must-start-with-letter", "must-not-end-with-dash-", "must-not-include-punctuation-chars-@\#$%^&*()",
+            "must-not-include-special-chars-ä", "must.not.include.dots"].each do |bad_value|
+            route.should_not allow_value(bad_value).for(:host).with_message(message)
+          end
 
-        subject.should ensure_length_of(:host).is_at_most(63)
+          route.should ensure_length_of(:host).is_at_most(63)
+        end
       end
-    end
 
-    describe "errors" do
-      before do
-        stub(subject).create! { raise CFoundry::RouteHostTaken.new("the host is taken", 210003) }
-      end
+      describe "errors" do
+        before do
+          stub(route).create! { raise CFoundry::RouteHostTaken.new("the host is taken", 210003) }
+        end
 
-      it "populates errors on host" do
-        subject.create
-        subject.errors[:host].first.should =~ /the host is taken/i
+        it "populates errors on host" do
+          route.create
+          route.errors[:host].first.should =~ /the host is taken/i
+        end
       end
     end
   end

data/spec/cfoundry/v2/space_spec.rb

@@ -1,15 +1,13 @@
 require "spec_helper"
 
-describe CFoundry::V2::Space do
-  let(:client) { fake_client }
-
-  describe 'summarization' do
-    let(:mymodel) { CFoundry::V2::Space }
-    let(:myobject) { fake(:space) }
-    let(:summary_attributes) { { :name => "fizzbuzz" } }
-
-    subject { myobject }
-
-    it_behaves_like 'a summarizeable model'
+module CFoundry
+  module V2
+    describe Space do
+      it_behaves_like "a summarizeable model" do
+        let(:summary_attributes) { {:name => "fizzbuzz"} }
+        let(:client) { build(:client) }
+        subject { build(:space, :client => client) }
+      end
+    end
   end
 end

data/spec/cfoundry/validator_spec.rb

@@ -1,92 +1,94 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CFoundry::Validator do
-  subject { described_class }
+module CFoundry
+  describe Validator do
+    let(:validator) { described_class }
 
-  describe 'value_matches?' do
-    it 'returns true on nil values' do
-      subject.value_matches?(nil, :something).should be_true
-    end
+    describe "value_matches?" do
+      it "returns true on nil values" do
+        validator.value_matches?(nil, :something).should be_true
+      end
 
-    context 'with a type of Class' do
-      it 'returns true when value is of type class' do
-        subject.value_matches?(1, Integer).should be_true
+      context "with a type of Class" do
+        it "returns true when value is of type class" do
+          validator.value_matches?(1, Integer).should be_true
+        end
       end
-    end
 
-    context 'with a Regex' do
-      it 'returns true when the regex matches' do
-        subject.value_matches?('value', /lue/).should == true
+      context "with a Regex" do
+        it "returns true when the regex matches" do
+          validator.value_matches?("value", /lue/).should == true
+        end
       end
-    end
 
-    context 'with type of url' do
-      it 'requires http or https urls' do
-        subject.value_matches?('http:whatever', :url).should be_true
-        subject.value_matches?('https:whatever', :url).should be_true
-        subject.value_matches?('htt_no:whatever', :url).should be_false
+      context "with type of url" do
+        it "requires http or https urls" do
+          validator.value_matches?("http:whatever", :url).should be_true
+          validator.value_matches?("https:whatever", :url).should be_true
+          validator.value_matches?("htt_no:whatever", :url).should be_false
+        end
       end
-    end
 
-    context 'with type of https_url' do
-      it 'requires http or https urls' do
-        subject.value_matches?('https:whatever', :https_url).should be_true
-        subject.value_matches?('http:whatever', :https_url).should be_false
+      context "with type of https_url" do
+        it "requires http or https urls" do
+          validator.value_matches?("https:whatever", :https_url).should be_true
+          validator.value_matches?("http:whatever", :https_url).should be_false
+        end
       end
-    end
 
-    context 'with type boolean' do
-      it 'returns true on presence of true or false' do
-        subject.value_matches?(true, :boolean).should be_true
-        subject.value_matches?(false, :boolean).should be_true
-        subject.value_matches?('no boolean', :boolean).should be_false
+      context "with type boolean" do
+        it "returns true on presence of true or false" do
+          validator.value_matches?(true, :boolean).should be_true
+          validator.value_matches?(false, :boolean).should be_true
+          validator.value_matches?("no boolean", :boolean).should be_false
+        end
       end
-    end
 
-    context 'with an Array' do
-      it 'returns true when all elements are of same type' do
-        subject.value_matches?(['https:whatever'], [String]).should be_true
-        subject.value_matches?(['https:whatever'], [Integer]).should be_false
+      context "with an Array" do
+        it "returns true when all elements are of same type" do
+          validator.value_matches?(["https:whatever"], [String]).should be_true
+          validator.value_matches?(["https:whatever"], [Integer]).should be_false
+        end
       end
-    end
 
-    context 'with a hash' do
-      it 'returns true when specified types match' do
-        subject.value_matches?({:name => "thing"}, {:name => String}).should be_true
-        subject.value_matches?({:name => "thing", :unspecified => 1}, {:name => String}).should be_true
-        subject.value_matches?({:name => 1}, {:name => String}).should be_false
+      context "with a hash" do
+        it "returns true when specified types match" do
+          validator.value_matches?({:name => "thing"}, {:name => String}).should be_true
+          validator.value_matches?({:name => "thing", :unspecified => 1}, {:name => String}).should be_true
+          validator.value_matches?({:name => 1}, {:name => String}).should be_false
+        end
       end
-    end
 
-    it 'returns true when type is nil' do
-      subject.value_matches?('some value', nil).should be_true
-    end
+      it "returns true when type is nil" do
+        validator.value_matches?("some value", nil).should be_true
+      end
 
-    context 'with a symbol' do
-      it 'returns true when the value is of specified type' do
-        subject.value_matches?('some value', :string).should be_true
-        subject.value_matches?('some value', :integer).should be_false
+      context "with a symbol" do
+        it "returns true when the value is of specified type" do
+          validator.value_matches?("some value", :string).should be_true
+          validator.value_matches?("some value", :integer).should be_false
+        end
       end
     end
-  end
 
-  describe 'validate_type' do
-    it 'passes validation with a nil value' do
-      expect {
-      subject.validate_type(nil, :whatever)
-      }.to_not raise_error
-    end
+    describe "validate_type" do
+      it "passes validation with a nil value" do
+        expect {
+          validator.validate_type(nil, :whatever)
+        }.to_not raise_error
+      end
 
-    it 'passes validation when the value matches' do
-      expect {
-        subject.validate_type('string', :string)
-      }.to_not raise_error
-    end
+      it "passes validation when the value matches" do
+        expect {
+          validator.validate_type("string", :string)
+        }.to_not raise_error
+      end
 
-    it 'raises a validation error when value does not match' do
-      expect {
-        subject.validate_type('string', :integer)
-      }.to raise_error(CFoundry::Mismatch)
+      it "raises a validation error when value does not match" do
+        expect {
+          validator.validate_type("string", :integer)
+        }.to raise_error(CFoundry::Mismatch)
+      end
     end
   end
-end
+end

data/spec/factories/app_events_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :app_event, :class => CFoundry::V2::AppEvent do
+    sequence(:guid) { |n| "app-event-guid-#{n}" }
+
+    initialize_with { new(guid, build(:client)) }
+  end
+end

data/spec/factories/apps_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :app, :class => CFoundry::V2::App do
+    sequence(:guid) { |n| "app-guid-#{n}" }
+    ignore do
+      manifest { {} }
+      client { FactoryGirl.build(:client) }
+    end
+
+    initialize_with { new(guid, client, manifest) }
+  end
+end

data/spec/factories/clients_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :client, :class => CFoundry::V2::Client do
+
+  end
+end

data/spec/factories/domains_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :domain, :class => CFoundry::V2::Domain do
+    sequence(:guid) { |n| "domain-guid-#{n}" }
+
+    initialize_with { new(guid, build(:client)) }
+  end
+end

data/spec/factories/organizations_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :organization, :class => CFoundry::V2::Organization do
+    sequence(:guid) { |n| "organization-guid-#{n}" }
+
+    ignore do
+      client { FactoryGirl.build(:client) }
+    end
+
+    initialize_with { new(guid, client) }
+  end
+end