cf 1.1.4 → 2.0.0

data/spec/cf/cli/route/unmap_spec.rb

@@ -5,11 +5,16 @@ describe CF::Route::Unmap do
     stub_client_and_precondition
   end
 
-  let(:client) { fake_client :apps => [app] }
+  let(:client) do
+    build(:client).tap do |client|
+      client.stub(:apps).and_return([app])
+      client.stub(:apps_by_name).and_return([app])
+    end
+  end
 
-  let(:app){ fake(:app, :space => space, :name => "app-name") }
-  let(:space) { fake(:space, :name => "space-name", :domains => space_domains) }
-  let(:domain) { fake(:domain, :name => domain_name ) }
+  let(:app){ build(:app, :space => space, :name => "app-name") }
+  let(:space) { build(:space, :name => "space-name", :domains => space_domains) }
+  let(:domain) { build(:domain, :name => domain_name ) }
   let(:domain_name) { "some-domain.com" }
   let(:host_name) { "some-host" }
   let(:url) { "#{host_name}.#{domain_name}" }
@@ -38,8 +43,8 @@ describe CF::Route::Unmap do
     subject { cf %W[unmap #{url} #{app.name}] }
 
     context "when the given route is mapped to the given app" do
-      let(:app) { fake(:app, :space => space, :name => "app-name", :routes => [route]) }
-      let(:route) { fake(:route, :space => space, :host => host_name, :domain => domain) }
+      let(:app) { build(:app, :space => space, :name => "app-name", :routes => [route]) }
+      let(:route) { build(:route, :space => space, :host => host_name, :domain => domain) }
 
       it "unmaps the url from the app" do
         app.should_receive(:remove_route).with(route)
@@ -49,6 +54,7 @@ describe CF::Route::Unmap do
 
     context "when the given route is NOT mapped to the given app" do
       it "displays an error" do
+        app.stub(:routes).and_return([])
         subject
         expect(error_output).to say("Unknown route")
       end
@@ -56,14 +62,14 @@ describe CF::Route::Unmap do
   end
 
   context "when only an app is specified" do
-    let(:other_route) { fake(:route, :host => "abcd", :domain => domain) }
-    let(:route) { fake(:route, :host => "efgh", :domain => domain) }
-    let(:app) { fake(:app, :space => space, :routes => [route, other_route] )}
+    let(:other_route) { build(:route, :host => "abcd", :domain => domain) }
+    let(:route) { build(:route, :host => "efgh", :domain => domain) }
+    let(:app) { build(:app, :space => space, :routes => [route, other_route] )}
 
     subject { cf %W[unmap --app #{app.name}] }
 
     it "asks the user to select from the app's urls" do
-      mock_ask("Which URL?", anything) do |_, opts|
+      should_ask("Which URL?", anything) do |_, opts|
         expect(opts[:choices]).to eq [other_route, route]
         route
       end
@@ -81,9 +87,9 @@ describe CF::Route::Unmap do
   end
 
   context "when an app is specified and the --all option is given" do
-    let(:other_route) { fake(:route, :host => "abcd", :domain => domain) }
-    let(:route) { fake(:route, :host => "efgh", :domain => domain) }
-    let(:app) { fake(:app, :routes => [route, other_route]) }
+    let(:other_route) { build(:route, :host => "abcd", :domain => domain) }
+    let(:route) { build(:route, :host => "efgh", :domain => domain) }
+    let(:app) { build(:app, :routes => [route, other_route]) }
 
     subject { cf %W[unmap --all --app #{app.name}] }
 
@@ -95,8 +101,8 @@ describe CF::Route::Unmap do
   end
 
   context "when only a url is passed" do
-    let(:route) { fake(:route, :host => host_name, :domain => domain) }
-    let(:client) { fake_client :routes => [route] }
+    let(:route) { build(:route, :host => host_name, :domain => domain) }
+    before { client.stub(:routes).and_return([route]) }
 
     subject { cf %W[unmap #{url}] }
 

data/spec/cf/cli/service/create_spec.rb

@@ -3,6 +3,12 @@ require "spec_helper"
 module CF
   module Service
     describe Create do
+      let(:client) { build(:client) }
+
+      before do
+        stub_client_and_precondition
+      end
+
       describe "metadata" do
         let(:command) { Mothership.commands[:create_service] }
 
@@ -23,23 +29,22 @@ module CF
       end
 
       context "when there are services" do
-        let(:service_plan) { fake(:service_plan, :name => "F20") }
-        let(:selected_service) { fake(:service, :label => "Foo Service", :service_plans => [service_plan]) }
+        let(:service_plan) { build(:service_plan, :name => "F20") }
+        let(:selected_service) { build(:service, :label => "Foo Service", :service_plans => [service_plan]) }
         let(:command) { Mothership.new.invoke(:create_service, params, {}) }
-        let(:client) { fake_client(:services => services) }
         let(:params) { {} }
 
         before do
-          CF::CLI.any_instance.stub(:client).and_return(client)
+          client.stub(:services).and_return(services)
         end
 
         describe "when there is at least one service" do
           let(:services) { [selected_service] }
 
           it "asks for the service" do
-            mock_ask("What kind?", anything) { selected_service }
-            mock_ask("Name?", anything) { selected_service.label }
-            mock_ask("Which plan?", anything) { service_plan }
+            should_ask("What kind?", anything) { selected_service }
+            should_ask("Name?", anything) { selected_service.label }
+            should_ask("Which plan?", anything) { service_plan }
             CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
 
             capture_output { command }
@@ -47,12 +52,12 @@ module CF
         end
 
         describe "when there are more than one services" do
-          let(:services) { [selected_service, fake(:service), fake(:service)] }
+          let(:services) { [selected_service, build(:service), build(:service)] }
 
           it "asks for the service" do
-            mock_ask("What kind?", anything) { selected_service }
-            mock_ask("Name?", anything) { selected_service.label }
-            mock_ask("Which plan?", anything) { service_plan }
+            should_ask("What kind?", anything) { selected_service }
+            should_ask("Name?", anything) { selected_service.label }
+            should_ask("Which plan?", anything) { service_plan }
             CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
 
             capture_output { command }
@@ -75,7 +80,7 @@ module CF
         end
 
         describe "when entering command line options" do
-          let(:service_plan) { fake(:service_plan, :name => "f20") }
+          let(:service_plan) { build(:service_plan, :name => "f20") }
           let(:params) { {
             :name => "my-service-name",
             :offering => selected_service,

data/spec/cf/cli/service/rename_spec.rb

@@ -4,14 +4,17 @@ describe CF::Service::Rename do
   let(:global) { { :color => false, :quiet => true } }
   let(:inputs) { {} }
   let(:given) { {} }
-  let(:client) { fake_client }
+  let(:client) { build(:client) }
   let(:service) {}
+  let(:services) { [] }
   let(:new_name) { "some-new-name" }
 
   subject { Mothership.new.invoke(:rename_service, inputs, given, global) }
 
   before do
     CF::CLI.any_instance.stub(:client).and_return(client)
+    client.stub(:service_instances => services)
+    client.stub(:service_instances_by_name => services)
   end
 
   describe "metadata" do
@@ -48,14 +51,13 @@ describe CF::Service::Rename do
   end
 
   context "when there are services" do
-    let(:client) { fake_client(:service_instances => services) }
-    let(:services) { fake_list(:service_instance, 2) }
+    let(:services) { Array.new(2) { build(:service_instance) } }
     let(:renamed_service) { services.first }
 
     context "when the defaults are used" do
       it "asks for the service and new name and renames" do
-        mock_ask("Rename which service?", anything) { renamed_service }
-        mock_ask("New name") { new_name }
+        should_ask("Rename which service?", anything) { renamed_service }
+        should_ask("New name") { new_name }
         renamed_service.should_receive(:name=).with(new_name)
         renamed_service.should_receive(:update!)
         subject
@@ -67,7 +69,7 @@ describe CF::Service::Rename do
 
       it "asks for the new name and renames" do
         dont_allow_ask("Rename which service?", anything)
-        mock_ask("New name") { new_name }
+        should_ask("New name") { new_name }
         renamed_service.should_receive(:name=).with(new_name)
         renamed_service.should_receive(:update!)
         subject

data/spec/cf/cli/service/services_spec.rb

@@ -33,20 +33,27 @@ module CF
         let(:global) { {:color => false} }
         let(:inputs) { {} }
         let(:given) { {} }
-        let(:client) { fake_client(:current_space => current_space, :service_instances => service_instances) }
+        let(:client) do
+          build(:client).tap do |client|
+            client.stub(:current_space => current_space, :service_instances => service_instances)
+          end
+        end
+        let(:app) { build(:app) }
 
-        let(:service_plan) { fake(:service_plan, :service => fake(:service, :version => "service_version", :provider => "provider")) }
-        let(:service1) { fake(:service_instance, :service_plan => service_plan) }
+        let(:service_plan) { build(:service_plan, :service => build(:service, :version => "service_version", :provider => "provider")) }
+        let(:service_binding) { build(:service_binding, :app => app) }
+        let(:service1) { build(:service_instance, :service_plan => service_plan, :service_bindings => [service_binding]) }
 
         let(:service_instances) { [service1] }
-        let(:current_space) { fake(:space, :name => "the space") }
+        let(:current_space) { build(:space, :name => "the space") }
 
         subject do
           capture_output { Mothership.new.invoke(:services, inputs, given, global) }
         end
 
         before do
-          CF::CLI.any_instance.stub(:client).and_return(client)
+          stub_client_and_precondition
+          client.stub(:service_bindings).and_return([service_binding])
         end
 
         it "produces a table of services" do
@@ -57,12 +64,12 @@ module CF
           expect(output).to match /Getting services in the space.*OK/
 
           expect(output).to match /name\s+service\s+provider\s+version\s+plan\s+bound apps/
-          expect(output).to match /service_instance-.+?\s+  # name
+          expect(output).to match /service-instance-.+?\s+  # name
         service-.*?\s+                                  # service
         provider.*?\s+                                  # provider
         service_version\s+                              # version
-        service_plan-.*?\s+                             # plan
-        none\s+                                         # bound apps
+        service-plan-.*?\s+                             # plan
+        app-name-\d+\s+                                         # bound apps
         /x
 
         end

data/spec/cf/cli/space/create_spec.rb

@@ -3,6 +3,9 @@ require "spec_helper"
 module CF
   module Space
     describe Create do
+      let(:client) { build(:client) }
+      before { stub_client_and_precondition }
+
       describe "metadata" do
         let(:command) { Mothership.commands[:create_space] }
 
@@ -26,13 +29,8 @@ module CF
       end
 
       describe "running the command" do
-        let(:new_space) { fake(:space, :name => new_name) }
-        let(:new_name) { "some-new-name" }
-
-        let(:spaces) { [new_space] }
-        let(:organization) { fake(:organization, :spaces => spaces) }
-
-        let(:client) { fake_client(:current_organization => organization, :spaces => spaces) }
+        let(:new_space) { build(:space) }
+        let(:organization) { build(:organization, :spaces => [new_space]) }
 
         before do
           client.stub(:space).and_return(new_space)
@@ -40,8 +38,6 @@ module CF
           new_space.stub(:add_manager)
           new_space.stub(:add_developer)
           new_space.stub(:add_auditor)
-          described_class.any_instance.stub(:client).and_return(client)
-          described_class.any_instance.stub(:precondition).and_return(nil)
           CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
           CF::Populators::Organization.any_instance.stub(:choices).and_return([organization])
         end

data/spec/cf/cli/space/delete_spec.rb

@@ -3,6 +3,9 @@ require "spec_helper"
 module CF
   module Space
     describe Delete do
+      let(:client) { build(:client) }
+      before { stub_client_and_precondition }
+
       describe "metadata" do
         let(:command) { Mothership.commands[:delete_space] }
 
@@ -16,26 +19,24 @@ module CF
       end
 
       describe "running the command" do
-        let(:space) { fake :space, :name => "some_space_name" }
-        let(:organization) { fake(:organization, :spaces => [space], :name => "MyOrg") }
-        let(:client) { fake_client(:current_organization => organization, :spaces => [space]) }
+        let(:space) { build :space, :name => "some_space_name" }
+        let(:organization) { build(:organization, :spaces => [space], :name => "MyOrg") }
 
         subject { capture_output { cf %W[delete-space some_space_name --quiet --force] } }
 
         before do
-          described_class.any_instance.stub(:client) { client }
-          described_class.any_instance.stub(:precondition)
           CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
+          organization.stub(:spaces_by_name).with("some_space_name").and_return([space])
           space.stub(:delete!)
         end
 
-
         context "without the force parameter when prompting" do
           subject { cf %W[delete-space some_space_name --quiet] }
+
           context "when the user responds 'y'" do
             it "deletes the space, exits cleanly" do
               space.should_receive(:delete!)
-              mock_ask("Really delete #{space.name}?", {:default => false}) { true }
+              should_ask("Really delete #{space.name}?", {:default => false}) { true }
 
               subject
               @status.should == 0
@@ -45,7 +46,7 @@ module CF
           context "when the user responds 'n'" do
             it "exits cleanly without deleting the space" do
               space.should_not_receive(:delete!)
-              mock_ask("Really delete #{space.name}?", {:default => false}) { false }
+              should_ask("Really delete #{space.name}?", {:default => false}) { false }
 
               subject
               @status.should == 0

data/spec/cf/cli/space/rename_spec.rb

@@ -3,14 +3,13 @@ require "spec_helper"
 module CF
   module Space
     describe Rename do
-      let(:spaces) { fake_list(:space, 3) }
-      let(:organization) { fake(:organization, :spaces => spaces) }
-      let(:client) { fake_client(:current_organization => organization, :spaces => spaces) }
+      let(:client) { build(:client) }
+      let(:spaces) { Array.new(3){ build(:space) } }
+      let(:organization) { build(:organization, :spaces => spaces) }
       let(:new_name) { "some-new-name" }
 
       before do
-        described_class.any_instance.stub(:client) { client }
-        described_class.any_instance.stub(:precondition)
+        stub_client_and_precondition
         CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
       end
 
@@ -39,6 +38,10 @@ module CF
       context "when there are no spaces" do
         let(:spaces) { [] }
 
+        before do
+          client.stub(:spaces_by_name).with("some-invalid-space").and_return(spaces)
+        end
+
         context "and a space is given" do
           subject { cf %W[rename-space --space some-invalid-space --no-force --no-quiet] }
           it "prints out an error message" do
@@ -60,10 +63,14 @@ module CF
         let(:renamed_space) { spaces.first }
         subject { cf %W[rename-space --no-force --no-quiet] }
 
+        before do
+          client.stub(:spaces_by_name).with(renamed_space.name).and_return(spaces)
+        end
+
         context "when the defaults are used" do
           it "asks for the space and new name and renames" do
-            mock_ask("Rename which space?", anything) { renamed_space }
-            mock_ask("New name") { new_name }
+            should_ask("Rename which space?", anything) { renamed_space }
+            should_ask("New name") { new_name }
             renamed_space.should_receive(:name=).with(new_name)
             renamed_space.should_receive(:update!)
             subject
@@ -75,7 +82,7 @@ module CF
 
           it "asks for the new name and renames" do
             dont_allow_ask("Rename which space?", anything)
-            mock_ask("New name") { new_name }
+            should_ask("New name") { new_name }
             renamed_space.should_receive(:name=).with(new_name)
             renamed_space.should_receive(:update!)
             subject

data/spec/cf/cli/space/space_spec.rb

@@ -25,19 +25,19 @@ module CF
       end
 
       describe "running the command" do
-        let(:apps) { fake_list(:app, 2) }
-        let(:domains) { fake_list(:domain, 2) }
-        let(:services) { fake_list(:service_instance, 2) }
-        let!(:space_1) { fake(:space, :name => "some_space_name", :apps => apps, :service_instances => services, :domains => domains) }
-        let(:spaces) { [space_1] }
-        let(:organization) { fake(:organization, :name => "Spacey Org", :spaces => spaces) }
-        let(:client) { fake_client(:spaces => spaces, :current_organization => organization) }
+        let(:client) { build(:client) }
+
+        let(:apps) { Array.new(2) { build(:app) } }
+        let(:domains) { Array.new(2) { build(:domain) } }
+        let(:services) { Array.new(2) { build(:service_instance) } }
+        let(:space) { build(:space, :name => "some_space_name", :apps => apps, :service_instances => services, :domains => domains, :organization => organization ) }
+        let(:spaces) { [space] }
+        let(:organization) { build(:organization, :name => "Spacey Org") }
 
         before do
-          CF::Space::Base.any_instance.stub(:client) { client }
-          CF::Space::Base.any_instance.stub(:precondition)
+          stub_client_and_precondition
           CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
-          CF::Populators::Space.any_instance.stub(:populate_and_save!).and_return(space_1)
+          CF::Populators::Space.any_instance.stub(:populate_and_save!).and_return(space)
         end
 
         context "with --quiet" do

data/spec/cf/cli/space/spaces_spec.rb

@@ -4,16 +4,22 @@ module CF
   module Space
     describe Spaces do
       let(:full) { false }
-      let!(:space_1) { fake(:space, :name => "bb_second", :apps => fake_list(:app, 2), :service_instances => [fake(:service_instance)]) }
-      let!(:space_2) { fake(:space, :name => "aa_first", :apps => [fake(:app)], :service_instances => fake_list(:service_instance, 3), :domains => [fake(:domain)]) }
-      let!(:space_3) { fake(:space, :name => "cc_last", :apps => fake_list(:app, 2), :service_instances => fake_list(:service_instance, 2), :domains => fake_list(:domain, 2)) }
+      let(:app) { build(:app) }
+      let!(:space_1) { build(:space, :name => "bb_second", :apps => [app], :service_instances => [build(:service_instance)]) }
+      let!(:space_2) { build(:space, :name => "aa_first", :apps => [app], :service_instances => [build(:service_instance)], :domains => [build(:domain)]) }
+      let!(:space_3) { build(:space, :name => "cc_last", :apps => [app], :service_instances => [build(:service_instance)], :domains => [build(:domain)]) }
       let(:spaces) { [space_1, space_2, space_3] }
-      let(:organization) { fake(:organization, :spaces => spaces, :name => "foo") }
-      let(:client) { fake_client(:spaces => spaces, :current_organization => organization) }
+      let(:organization) { build(:organization, :spaces => spaces, :name => "foo") }
+      let(:client) do
+        build(:client).tap do |client|
+          client.stub(:spaces => spaces, :current_organization => organization)
+        end
+      end
 
       before do
         stub_client_and_precondition
         CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
+        organization.stub(:spaces).and_return(spaces)
       end
 
       describe "metadata" do

data/spec/cf/cli/space/switch_space_spec.rb

@@ -4,13 +4,12 @@ module CF
   module Space
     describe Switch do
       let(:space_to_switch_to) { spaces.last }
-      let(:spaces) { fake_list(:space, 3) }
-      let(:organization) { fake(:organization, :spaces => spaces) }
-      let(:client) { fake_client(:current_organization => organization, :spaces => spaces) }
+      let(:spaces) { Array.new(3) { build(:space) } }
+      let(:organization) { build(:organization, :spaces => spaces) }
+      let(:client) { build(:client) }
 
       before do
-        CF::Space::Base.any_instance.stub(:client) { client }
-        CF::Space::Base.any_instance.stub(:precondition)
+        stub_client_and_precondition
         CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
       end
 
@@ -38,6 +37,7 @@ module CF
       context "when the space exists" do
         before do
           Mothership.any_instance.should_receive(:invoke).with(:target, {:space => space_to_switch_to})
+          client.stub(:spaces_by_name).with(space_to_switch_to.name).and_return([space_to_switch_to])
         end
 
         it "switches to that space" do
@@ -46,11 +46,11 @@ module CF
       end
 
       context "when the space does not exist" do
-        let(:space_to_switch_to) { fake(:space, :name => "unique-name") }
+        before { client.stub(:spaces_by_name).with(space_to_switch_to.name).and_return([]) }
 
         it_behaves_like "an error that gets passed through",
           :with_exception => CF::UserError,
-          :with_message => "The space unique-name does not exist, please create the space first."
+          :with_message => /The space .* does not exist, please create the space first/
       end
     end
   end