cf 1.1.3.rc1 → 1.1.4

data/spec/cf/cli/populators/target_spec.rb

@@ -1,18 +1,23 @@
 require "spec_helper"
-require "webmock/rspec"
-require "cf/cli/populators/target"
 
-describe CF::Populators::Target do
-  describe "#populate_and_save!" do
-    let(:input) { stub! }
-    let(:organization) { stub! }
+module CF
+  module Populators
+    describe Target do
+      describe "#populate_and_save!" do
+        let(:input) { double(:input) }
+        let(:organization) { double(:organization) }
+        let(:space) { double(:space) }
 
-    subject { CF::Populators::Target.new(input).populate_and_save! }
+        subject { Target.new(input).populate_and_save! }
 
-    it "uses a organization then a space populator" do
-      mock(CF::Populators::Organization).new(input) { mock!.populate_and_save! { organization } }
-      mock(CF::Populators::Space).new(input, organization) { mock!.populate_and_save! }
-      subject
+        it "uses a organization then a space populator" do
+          organization.should_receive(:populate_and_save!).and_return(organization)
+          space.should_receive(:populate_and_save!)
+          Organization.should_receive(:new).with(input).and_return(organization)
+          Space.should_receive(:new).with(input, organization).and_return(space)
+          subject
+        end
+      end
     end
   end
-end
+end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe CF::Route::Delete do
   before do
     stub_client_and_precondition
-    stub(route).delete!
+    route.stub(:delete!)
   end
 
   let(:route) { fake(:route, :host => host_name, :domain => domain) }
@@ -47,7 +47,7 @@ describe CF::Route::Delete do
       end
 
       it "deletes the route" do
-        mock(route).delete!
+        route.should_receive(:delete!)
         command
       end
 
@@ -63,7 +63,7 @@ describe CF::Route::Delete do
       end
 
       it "does not delete the route" do
-        dont_allow(route).delete!
+        route.should_not_receive(:delete!)
         command
       end
 
@@ -78,7 +78,7 @@ describe CF::Route::Delete do
     let(:command) { cf %W[delete-route #{url} --force] }
 
     it "deletes the route" do
-      mock(route).delete!
+      route.should_receive(:delete!)
       command
     end
 

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

@@ -1,125 +1,129 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::Route::Map do
-  before do
-    stub_client_and_precondition
-  end
-
-  let(:client) { fake_client(:apps => apps, :routes => routes) }
-
-  let(:app) { fake(:app, :space => space, :name => "app-name") }
-  let(:space) { fake(:space, :domains => space_domains) }
-  let(:domain) { fake(:domain) }
-
-  let(:apps) { [app] }
-  let(:routes) { [] }
-  let(:domains) { [domain] }
+module CF
+  module Route
+    describe Map do
+      before do
+        stub_client_and_precondition
+      end
 
-  let(:space_domains) { domains }
+      let(:client) { fake_client(:apps => apps, :routes => routes) }
+
+      let(:app) { fake(:app, :space => space, :name => "app-name") }
+      let(:space) { fake(:space, :domains => space_domains).as_null_object }
+      let(:domain) { fake(:domain, :name => "domain-name-1").as_null_object }
+
+      let(:apps) { [app] }
+      let(:routes) { [] }
+      let(:domains) { [domain] }
+
+      let(:space_domains) { domains }
+
+      let(:host_name) { "some-host" }
+
+      shared_examples "mapping the route to the app" do
+        context "and the domain is mapped to the space" do
+          let(:space_domains) { [domain] }
+
+          context "and the route is mapped to the space" do
+            let(:routes) { [route] }
+            let(:route) do
+              fake(:route, :space => space, :host => host_name,
+                :domain => domain)
+            end
+
+            it "binds the route to the app" do
+              app.should_receive(:add_route).with(route)
+              subject
+            end
+          end
+
+          context "and the route is not mapped to the space" do
+            let(:new_route) { fake(:route) }
+
+            before do
+              client.stub(:route).and_return(new_route)
+              app.stub(:add_route)
+              new_route.stub(:create!)
+            end
+
+            it "indicates that it is creating a route" do
+              subject
+              expect(output).to say("Creating route #{host_name}.#{domain.name}")
+            end
+
+            it "creates the route in the app's space" do
+              new_route.should_receive(:create!)
+              subject
+              expect(new_route.host).to eq host_name
+              expect(new_route.domain).to eq domain
+              expect(new_route.space).to eq space
+            end
+
+            it "indicates that it is binding the route" do
+              subject
+              expect(output).to say("Binding #{host_name}.#{domain.name} to #{app.name}")
+            end
+
+            it "binds the route to the app" do
+              app.should_receive(:add_route).with(new_route)
+              subject
+            end
+          end
+        end
+      end
 
-  let(:host_name) { "some-host" }
+      context "when an app is specified" do
+        subject { cf(%W[map #{app.name} #{host_name} #{domain.name}]) }
 
-  shared_examples "mapping the route to the app" do
-    context 'and the domain is mapped to the space' do
-      let(:space_domains) { [domain] }
+        context "and the domain is not already mapped to the space" do
+          let(:space_domains) { [] }
 
-      context 'and the route is mapped to the space' do
-        let(:routes) { [route] }
-        let(:route) do
-          fake(:route, :space => space, :host => host_name,
-               :domain => domain)
+          it "indicates that the domain is invalid" do
+            subject
+            expect(error_output).to say("Unknown domain")
+          end
         end
 
-        it 'binds the route to the app' do
-          mock(app).add_route(route)
-          subject
-        end
+        include_examples "mapping the route to the app"
       end
 
-      context 'and the route is not mapped to the space' do
-        let(:new_route) { fake(:route) }
-
-        before do
-          stub(client).route { new_route }
-          stub(app).add_route
-          stub(new_route).create!
-        end
-
-        it 'indicates that it is creating a route' do
-          subject
-          expect(output).to say("Creating route #{host_name}.#{domain.name}")
-        end
+      context "when an app is not specified" do
+        let(:space_domains) { [domain] }
+        let(:new_route) { double(:route).as_null_object }
 
-        it "creates the route in the app's space" do
-          mock(new_route).create!
-          subject
-          expect(new_route.host).to eq host_name
-          expect(new_route.domain).to eq domain
-          expect(new_route.space).to eq space
-        end
+        subject { cf %W[map --host #{host_name} #{domain.name}] }
 
-        it 'indicates that it is binding the route' do
-          subject
-          expect(output).to say("Binding #{host_name}.#{domain.name} to #{app.name}")
-        end
+        before { stub_ask("Which application?", anything) { app } }
 
-        it 'binds the route to the app' do
-          mock(app).add_route(new_route)
+        it "asks for an app" do
+          client.stub(:route).and_return(new_route)
+          app.stub(:add_route)
+          new_route.stub(:create!)
+          mock_ask("Which application?", anything) { app }
           subject
         end
-      end
-    end
-  end
-
-  context 'when an app is specified' do
-    subject { cf %W[map #{app.name} #{host_name} #{domain.name}] }
 
-    context 'and the domain is not already mapped to the space' do
-      let(:space_domains) { [] }
-
-      it 'indicates that the domain is invalid' do
-        subject
-        expect(error_output).to say("Unknown domain")
+        include_examples "mapping the route to the app"
       end
-    end
-
-    include_examples "mapping the route to the app"
-  end
-
-  context 'when an app is not specified' do
-    let(:space_domains) { [domain] }
-    let(:new_route) { fake(:route) }
-
-    subject { cf %W[map --host #{host_name} #{domain.name}] }
-
-    before { stub_ask("Which application?", anything) { app } }
 
-    it 'asks for an app' do
-      stub(client).route { new_route }
-      stub(app).add_route
-      stub(new_route).create!
-      mock_ask("Which application?", anything) { app }
-      subject
-    end
-
-    include_examples "mapping the route to the app"
-  end
+      context "when a host is not specified" do
+        let(:new_route) { build(:route) }
 
-  context "when a host is not specified" do
-    let(:new_route) { fake(:route) }
+        subject { cf %W[map #{app.name} #{domain.name}] }
 
-    subject { cf %W[map #{app.name} #{domain.name}] }
-
-    before do
-      stub(client).route { new_route }
-      stub(app).add_route
-      stub(new_route).create!
-    end
+        before do
+          client.stub(:route).and_return(new_route)
+          app.stub(:add_route)
+          new_route.stub(:create!)
+        end
 
-    it "creates a route with an empty string as its host" do
-      mock(new_route).create!
-      subject
-      expect(new_route.host).to eq ""
+        it "creates a route with an empty string as its host" do
+          new_route.should_receive(:create!)
+          subject
+          expect(new_route.host).to eq ""
+        end
+      end
     end
   end
 end

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

@@ -42,7 +42,7 @@ describe CF::Route::Unmap do
       let(:route) { fake(:route, :space => space, :host => host_name, :domain => domain) }
 
       it "unmaps the url from the app" do
-        mock(app).remove_route(route)
+        app.should_receive(:remove_route).with(route)
         subject
       end
     end
@@ -68,14 +68,14 @@ describe CF::Route::Unmap do
         route
       end
 
-      stub(app).remove_route(anything)
+      app.stub(:remove_route)
 
       subject
     end
 
     it "unmaps the selected url from the app" do
       stub_ask("Which URL?", anything) { route }
-      mock(app).remove_route(route)
+      app.should_receive(:remove_route).with(route)
       subject
     end
   end
@@ -88,8 +88,8 @@ describe CF::Route::Unmap do
     subject { cf %W[unmap --all --app #{app.name}] }
 
     it "unmaps all routes from the given app" do
-      mock(app).remove_route(route)
-      mock(app).remove_route(other_route)
+      app.should_receive(:remove_route).with(route)
+      app.should_receive(:remove_route).with(other_route)
       subject
     end
   end

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

@@ -1,65 +1,93 @@
 require "spec_helper"
 
-module CF::Service
-  describe Create do
-    before do
-      any_instance_of(CF::CLI) do |cli|
-        stub(cli).client { client }
-      end
-    end
+module CF
+  module Service
+    describe Create do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:create_service] }
 
-    describe "metadata" do
-      let(:command) { Mothership.commands[:create_service] }
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Create a service" }
+          it { expect(Mothership::Help.group(:services, :manage)).to include(subject) }
+        end
 
-      describe "command" do
-        subject { command }
-        its(:description) { should eq "Create a service" }
-        it { expect(Mothership::Help.group(:services, :manage)).to include(subject) }
+        include_examples "inputs must have descriptions"
+
+        describe "arguments" do
+          subject { command.arguments }
+          it "has the correct argument order" do
+            should eq([{:type => :optional, :value => nil, :name => :offering}, {:type => :optional, :value => nil, :name => :name}])
+          end
+        end
       end
 
-      include_examples "inputs must have descriptions"
+      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(:command) { Mothership.new.invoke(:create_service, params, {}) }
+        let(:client) { fake_client(:services => services) }
+        let(:params) { {} }
 
-      describe "arguments" do
-        subject { command.arguments }
-        it "has the correct argument order" do
-          should eq([{:type => :optional, :value => nil, :name => :offering}, {:type => :optional, :value => nil, :name => :name}])
+        before do
+          CF::CLI.any_instance.stub(:client).and_return(client)
         end
-      end
-    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(:command) { Mothership.new.invoke(:create_service, {}, {}) }
-      let(:client) { fake_client(:services => services) }
-
-      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 }
-          any_instance_of(CFoundry::V2::ServiceInstance) do |service_instance|
-            stub(service_instance).create!
+        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 }
+            CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
+
+            capture_output { command }
           end
+        end
+
+        describe "when there are more than one services" do
+          let(:services) { [selected_service, fake(:service), fake(:service)] }
 
-          capture_output { command }
+          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 }
+            CFoundry::V2::ServiceInstance.any_instance.stub(:create!)
+
+            capture_output { command }
+          end
         end
-      end
 
-      describe "when there are more than one services" do
-        let(:services) { [selected_service, fake(:service), fake(:service)] }
+        describe "when the service plan is specified by an object, not a string" do
+          let(:services) { [selected_service] }
+          let(:params) { {
+            :name => "my-service-name",
+            :offering => selected_service,
+            :plan => service_plan,
+          } }
 
-        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 }
-          any_instance_of(CFoundry::V2::ServiceInstance) do |service_instance|
-            stub(service_instance).create!
+          it "creates the specified service" do
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:create!)
+            capture_output { command }
           end
+        end
 
-          capture_output { command }
+        describe "when entering command line options" do
+          let(:service_plan) { fake(:service_plan, :name => "f20") }
+          let(:params) { {
+            :name => "my-service-name",
+            :offering => selected_service,
+            :plan => "F20",
+          } }
+          let(:services) { [selected_service] }
+
+          it "uses case insensitive match" do
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:service_plan=).with(service_plan)
+            CFoundry::V2::ServiceInstance.any_instance.should_receive(:create!)
+            capture_output { command }
+          end
         end
       end
     end