cf 1.1.3.rc1 → 1.1.4

data/spec/console/console_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
-describe "CFConsole" do
+describe CFConsole do
   before do
-    @app = mock("app")
+    @app = double("app")
     @console = CFConsole.new(nil, @app)
   end
 
   it "should return connection info for apps that have a console ip and port" do
-    instance = mock("instance")
-    mock(@app).instances { [instance] }
-    mock(instance).console { {:ip => "192.168.1.1", :port => 3344} }
+    instance = double("instance")
+    @app.should_receive(:instances) { [instance] }
+    instance.should_receive(:console) { {:ip => "192.168.1.1", :port => 3344} }
 
     @console.get_connection_info(nil).should == {
       "hostname" => "192.168.1.1",
@@ -18,7 +18,7 @@ describe "CFConsole" do
   end
 
   it "should raise error when no app instances found" do
-    mock(@app).instances { [] }
+    @app.should_receive(:instances) { [] }
 
     expect {
       @console.get_connection_info(nil)
@@ -26,9 +26,9 @@ describe "CFConsole" do
   end
 
   it "should raise error when app does not have console access" do
-    instance = mock("instance")
-    mock(@app).instances { [instance] }
-    mock(instance).console { nil }
+    instance = double("instance")
+    @app.should_receive(:instances) { [instance] }
+    instance.should_receive(:console) { nil }
 
     expect {
       @console.get_connection_info(nil)
@@ -46,7 +46,7 @@ describe "CFConsole" do
 
     context "when console credentials cannot be obtained" do
       it "should raise error" do
-        mock(@app).file(*@creds[:path]) { "username: cfuser" }
+        @app.should_receive(:file).with(*@creds[:path]) { "username: cfuser" }
 
         expect {
           @console.start_console
@@ -56,63 +56,63 @@ describe "CFConsole" do
 
     context "when console credentials can be obtained" do
       before do
-        mock(@app).file(*@creds[:path]) { @creds[:yaml] }
+        @app.should_receive(:file).with(*@creds[:path]) { @creds[:yaml] }
         @telnet = Object.new
-        mock(@console).telnet_client { @telnet }
+        @console.should_receive(:telnet_client).and_return(@telnet)
       end
 
       it "should raise error if authentication fails" do
-        mock(@telnet).login(@creds[:telnet]) { "Login failed" }
-        mock(@telnet).close
+        @telnet.should_receive(:login).with(@creds[:telnet]) { "Login failed" }
+        @telnet.should_receive(:close)
 
         expect { @console.start_console }.to raise_error("Login failed")
       end
 
       it "should retry authentication on timeout" do
-        mock(@telnet).login(@creds[:telnet]){ raise TimeoutError }
-        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
+        @telnet.should_receive(:login).with(@creds[:telnet]){ raise TimeoutError }
+        @telnet.should_receive(:login).with(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
       end
 
       it "should retry authentication on EOF" do
-        mock(@console).telnet_client { @telnet }
-        mock(@telnet).login(@creds[:telnet]) { raise EOFError }
-        mock(@telnet).close
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
+        @console.should_receive(:telnet_client).and_return(@telnet)
+        @telnet.should_receive(:login).with(@creds[:telnet]) { raise EOFError }
+        @telnet.should_receive(:close)
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
       end
 
       it "should operate console interactively" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-        mock(Readline::HISTORY).push("puts 'hi'")
-        mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
-        mock(@console).puts("nil")
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        Readline.should_receive(:readline).with("irb():001:0> ") { "puts 'hi'" }
+        Readline::HISTORY.should_receive(:push).with("puts 'hi'")
+        @telnet.should_receive(:cmd).with("puts 'hi'").and_return("nil" + "\n" + "irb():002:0> ")
+        @console.should_receive(:puts).with("nil")
         verify_console_exit("irb():002:0> ")
 
         @console.start_console
       end
 
       it "should not crash if command times out" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-        mock(Readline::HISTORY).push("puts 'hi'")
-        mock(@telnet).cmd("puts 'hi'") { raise TimeoutError }
-        mock(@console).puts("Timed out sending command to server.")
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        Readline.should_receive(:readline).with("irb():001:0> ") { "puts 'hi'" }
+        Readline::HISTORY.should_receive(:push).with("puts 'hi'")
+        @telnet.should_receive(:cmd).with("puts 'hi'") { raise TimeoutError }
+        @console.should_receive(:puts).with("Timed out sending command to server.")
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
       end
 
       it "should raise error if an EOF is received" do
-        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-        mock(Readline::HISTORY).push("puts 'hi'")
-        mock(@telnet).cmd("puts 'hi'") { raise EOFError }
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("Switch to inspect mode\nirb():001:0> ")
+        Readline.should_receive(:readline).with("irb():001:0> ") { "puts 'hi'" }
+        Readline::HISTORY.should_receive(:push).with("puts 'hi'")
+        @telnet.should_receive(:cmd).with("puts 'hi'") { raise EOFError }
 
         expect {
           @console.start_console
@@ -120,30 +120,30 @@ describe "CFConsole" do
       end
 
       it "should not keep blank lines in history" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(Readline).readline("irb():001:0> ") { "" }
-        dont_allow(Readline::HISTORY).push("")
-        mock(@telnet).cmd("") { "irb():002:0*> " }
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        Readline.should_receive(:readline).with("irb():001:0> ") { "" }
+        Readline::HISTORY.should_not_receive(:push)
+        @telnet.should_receive(:cmd).and_return("irb():002:0*> ")
         verify_console_exit("irb():002:0*> ")
 
         @console.start_console
       end
 
       it "should not keep identical commands in history" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(Readline).readline("irb():001:0> ") { "puts 'hi'" }
-        mock(Readline::HISTORY).to_a { ["puts 'hi'"] }
-        dont_allow(Readline::HISTORY).push("puts 'hi'")
-        mock(@telnet).cmd("puts 'hi'") { "nil" + "\n" + "irb():002:0> " }
-        mock(@console).puts("nil")
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        Readline.should_receive(:readline).with("irb():001:0> ") { "puts 'hi'" }
+        Readline::HISTORY.should_receive(:to_a).and_return(["puts 'hi'"])
+        Readline::HISTORY.should_not_receive(:push).with("puts 'hi'")
+        @telnet.should_receive(:cmd).with("puts 'hi'").and_return("nil" + "\n" + "irb():002:0> ")
+        @console.should_receive(:puts).with("nil")
         verify_console_exit("irb():002:0> ")
 
         @console.start_console
       end
 
       it "should return tab completion data" do
-        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "to_s,nil?\n" }
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("Switch to inspect mode\nirb():001:0> ")
+        @telnet.should_receive(:cmd).with("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "to_s,nil?\n" }
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
@@ -151,8 +151,8 @@ describe "CFConsole" do
       end
 
       it "should return tab completion data receiving empty completion string" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "\n" }
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        @telnet.should_receive(:cmd).with("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { "\n" }
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
@@ -160,8 +160,8 @@ describe "CFConsole" do
       end
 
       it "should not crash on timeout of remote tab completion data" do
-        mock(@telnet).login(@creds[:telnet]) { "Switch to inspect mode\nirb():001:0> " }
-        mock(@telnet).cmd("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { raise TimeoutError }
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("Switch to inspect mode\nirb():001:0> ")
+        @telnet.should_receive(:cmd).with("String" => "app.\t", "Match" => /\S*\n$/, "Timeout" => 10) { raise TimeoutError }
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
@@ -169,11 +169,11 @@ describe "CFConsole" do
       end
 
       it "should properly initialize Readline for tab completion" do
-        mock(@telnet).login(@creds[:telnet]) { "irb():001:0> " }
-        mock(Readline).respond_to?("basic_word_break_characters=") { true }
-        mock(Readline).basic_word_break_characters=(" \t\n`><=;|&{(")
-        mock(Readline).completion_append_character=(nil)
-        mock(Readline).completion_proc=(anything)
+        @telnet.should_receive(:login).with(@creds[:telnet]).and_return("irb():001:0> ")
+        Readline.should_receive(:respond_to?).with("basic_word_break_characters=") { true }
+        Readline.should_receive(:basic_word_break_characters=).with(" \t\n`><=;|&{(")
+        Readline.should_receive(:completion_append_character=).with(nil)
+        Readline.should_receive(:completion_proc=).with(anything)
         verify_console_exit("irb():001:0> ")
 
         @console.start_console
@@ -182,8 +182,8 @@ describe "CFConsole" do
   end
 
   def verify_console_exit(prompt)
-    mock(Readline).readline(prompt) { "exit" }
-    mock(@telnet).cmd("String" => "exit", "Timeout" => 1) { raise TimeoutError }
-    mock(@telnet).close
+    Readline.should_receive(:readline).with(prompt) { "exit" }
+    @telnet.should_receive(:cmd).with("String" => "exit", "Timeout" => 1) { raise TimeoutError }
+    @telnet.should_receive(:close)
   end
 end

data/spec/factories/cfoundry/v2/domain_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :domain, :class => CFoundry::V2::Domain do
+    guid { "domain-id-1" }
+    name { "domain-name-1" }
+    client nil
+    initialize_with { new(guid, client) }
+  end
+end

data/spec/factories/cfoundry/v2/route_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :route, :class => CFoundry::V2::Route do
+    guid { "route-id-1" }
+    host { "route-host-1" }
+    client nil
+    initialize_with { new(guid, client) }
+  end
+end

data/spec/factories/cfoundry/v2/user_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :user, :class => CFoundry::V2::User do
+    guid { "user-id-1" }
+    client nil
+    initialize_with { new(guid, client) }
+  end
+end

data/spec/features/org_spec.rb

@@ -1,7 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
-
-if ENV['CF_V2_RUN_INTEGRATION']
+if ENV["CF_V2_RUN_INTEGRATION"]
   describe "creating and deleting orgs", :ruby19 => true do
     before(:all) do
       WebMock.allow_net_connect!
@@ -11,11 +10,11 @@ if ENV['CF_V2_RUN_INTEGRATION']
       WebMock.disable_net_connect!
     end
 
-    let(:target) { ENV['CF_V2_TEST_TARGET'] }
-    let(:organization) { ENV['CF_V2_TEST_ORGANIZATION'] }
-    let(:space) { ENV['CF_V2_TEST_SPACE'] }
-    let(:username) { ENV['CF_V2_ADMIN_USERNAME'] }
-    let(:password) { ENV['CF_V2_ADMIN_PW'] }
+    let(:target) { ENV["CF_V2_TEST_TARGET"] }
+    let(:organization) { ENV["CF_V2_TEST_ORGANIZATION"] }
+    let(:space) { ENV["CF_V2_TEST_SPACE"] }
+    let(:username) { ENV["CF_V2_ADMIN_USERNAME"] }
+    let(:password) { ENV["CF_V2_ADMIN_PW"] }
 
     let(:run_id) { TRAVIS_BUILD_ID.to_s + Time.new.to_f.to_s.gsub(".", "_") }
     let(:new_org_name) { "new-org-#{run_id}" }
@@ -47,9 +46,10 @@ if ENV['CF_V2_RUN_INTEGRATION']
         runner.should say "Creating space new-space... OK"
       end
 
-      BlueShell::Runner.run("cf delete-org #{new_org_name} --force") do |runner|
-        runner.should say "If you want to delete the organization along with all dependent objects, rerun the command with the '--recursive' flag."
-      end
+      # pending until cc change 442f08e72c0808baf85b948a8b56e58f025edf72 is on a1
+      #BlueShell::Runner.run("cf delete-org #{new_org_name} --force") do |runner|
+      #  runner.should say "If you want to delete the organization along with all dependent objects, rerun the command with the '--recursive' flag."
+      #end
 
       BlueShell::Runner.run("cf delete-org #{new_org_name} --force --recursive") do |runner|
         runner.should say("Deleting organization #{new_org_name}... OK")

data/spec/manifests/manifests_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe CFManifests do
   let(:inputs_hash) { {} }
@@ -9,7 +9,7 @@ describe CFManifests do
   let(:cmd) do
     manifest = CF::App::Push.new(nil, inputs)
     manifest.extend CFManifests
-    stub(manifest).client { client }
+    manifest.stub(:client) { client }
     manifest
   end
 
@@ -28,22 +28,22 @@ describe CFManifests do
   let(:manifest_file) { "/abc/manifest.yml" }
 
   before do
-    stub(cmd).target_base { target_base }
+    cmd.stub(:target_base) { target_base }
 
-    stub(cmd).manifest { manifest }
-    stub(cmd).manifest_file { manifest_file }
+    cmd.stub(:manifest) { manifest }
+    cmd.stub(:manifest_file) { manifest_file }
   end
 
-  describe '#find_apps' do
+  describe "#find_apps" do
     subject { cmd.find_apps(nil) }
 
-    context 'when there is no manifest file' do
-      before { stub(cmd).manifest { nil } }
+    context "when there is no manifest file" do
+      before { cmd.stub(:manifest).and_return(nil) }
       it { should eq [] }
     end
   end
 
-  describe '#create_manifest_for' do
+  describe "#create_manifest_for" do
     let(:app) {
       fake :app,
         :memory => 2048,
@@ -105,7 +105,7 @@ describe CFManifests do
       end
     end
 
-    context 'when there is no url' do
+    context "when there is no url" do
       let(:app) {
         fake :app,
           :memory => 2048,
@@ -115,7 +115,7 @@ describe CFManifests do
       its(["url"]) { should eq "none" }
     end
 
-    context 'when there is no command' do
+    context "when there is no command" do
       let(:app) {
         fake :app,
           :memory => 2048,
@@ -125,7 +125,7 @@ describe CFManifests do
       it { should_not include "command" }
     end
 
-    context 'when there are no service bindings' do
+    context "when there are no service bindings" do
       let(:app) {
         fake :app,
           :memory => 2048,
@@ -174,21 +174,21 @@ describe CFManifests do
           let(:service_bindings) { [fake(:service_binding, :service_instance => service_1)] }
 
           it "does neither create nor bind the service again" do
-            dont_allow(cmd).invoke :create_service, anything
-            dont_allow(cmd).invoke :bind_service, anything
+            cmd.should_not_receive(:invoke).with(:create_service, anything)
+            cmd.should_not_receive(:invoke).with(:bind_service, anything)
             cmd.send(:setup_services, app, info)
           end
         end
 
         context "but are not bound" do
           it "does not create the services" do
-            dont_allow(cmd).invoke :create_service, anything
-            stub(cmd).invoke :bind_service, anything
+            cmd.should_not_receive(:invoke).with(:create_service, anything)
+            cmd.stub(:invoke).with(:bind_service, anything)
             cmd.send(:setup_services, app, info)
           end
 
           it "binds the service" do
-            mock(cmd).invoke :bind_service, :app => app, :service => service_1
+            cmd.should_receive(:invoke).with(:bind_service, :app => app, :service => service_1)
             cmd.send(:setup_services, app, info)
           end
         end
@@ -196,9 +196,9 @@ describe CFManifests do
 
       context "and the services do not exist" do
         it "creates the services" do
-          mock(cmd).invoke :create_service, :app => app,
-            :name => service_1.name, :offering => mysql, :plan => plan_100
-          dont_allow(cmd).invoke :bind_service, anything
+          cmd.should_receive(:invoke).with(:create_service, :app => app,
+            :name => service_1.name, :offering => mysql, :plan => plan_100)
+          cmd.should_not_receive(:invoke).with(:bind_service, anything)
           cmd.send(:setup_services, app, info)
         end
       end
@@ -302,7 +302,7 @@ describe CFManifests do
     subject { cmd.current_apps }
 
     it "returns the applications with the cwd as their path" do
-      stub(Dir).pwd { "/abc" }
+      Dir.stub(:pwd) { "/abc" }
       expect(subject).to eq [{ :name => "foo", :path => "/abc"}, { :name => "bar", :path => "/abc" }]
     end
   end

data/spec/manifests/plugin_spec.rb

@@ -13,14 +13,14 @@ describe ManifestsPlugin do
   let(:client) { fake_client }
 
   before do
-    stub(plugin).manifest { manifest }
-    stub(plugin).manifest_file { manifest_file } if manifest_file
-    stub(plugin).client { client }
+    plugin.stub(:manifest) { manifest }
+    plugin.stub(:manifest_file) { manifest_file } if manifest_file
+    plugin.stub(:client) { client }
   end
 
   describe "#wrap_with_optional_name" do
     let(:name_made_optional) { true }
-    let(:wrapped) { mock! }
+    let(:wrapped) { double(:wrapped).as_null_object }
 
     subject { plugin.send(:wrap_with_optional_name, name_made_optional, wrapped, inputs) }
 
@@ -28,8 +28,8 @@ describe ManifestsPlugin do
       let(:inputs_hash) { { :all => true } }
 
       it "skips all manifest-related logic, and invokes the command" do
-        mock(wrapped).call
-        dont_allow(plugin).show_manifest_usage
+        wrapped.should_receive(:call)
+        plugin.should_not_receive(:show_manifest_usage)
         subject
       end
     end
@@ -41,8 +41,8 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "foo" } }
 
         it "passes through to the command" do
-          mock(wrapped).call
-          dont_allow(plugin).show_manifest_usage
+          wrapped.should_receive(:call)
+          plugin.should_not_receive(:show_manifest_usage)
           subject
         end
       end
@@ -52,7 +52,7 @@ describe ManifestsPlugin do
 
         context "and we made it optional" do
           it "fails manually" do
-            mock(plugin).no_apps
+            plugin.should_receive(:no_apps)
             subject
           end
         end
@@ -61,8 +61,8 @@ describe ManifestsPlugin do
           let(:name_made_optional) { false }
 
           it "passes through to the command" do
-            mock(wrapped).call
-            dont_allow(plugin).show_manifest_usage
+            wrapped.should_receive(:call)
+            plugin.should_not_receive(:show_manifest_usage)
             subject
           end
         end
@@ -73,7 +73,7 @@ describe ManifestsPlugin do
       let(:manifest_file) { "/abc/manifest.yml" }
 
       before do
-        stub(plugin).show_manifest_usage
+        plugin.stub(:show_manifest_usage)
       end
 
       context "when no apps are given" do
@@ -81,11 +81,11 @@ describe ManifestsPlugin do
           let(:manifest) { { :applications => [{ :name => "foo", :path => "/abc/foo" }] } }
 
           it "calls the command for only that app" do
-            mock(wrapped).call(anything) do |inputs|
+            wrapped.should_receive(:call).with(anything) do |inputs|
               expect(inputs.given[:app]).to eq "foo"
             end
 
-            stub(Dir).pwd { "/abc/foo" }
+            Dir.stub(:pwd) { "/abc/foo" }
 
             subject
           end
@@ -96,7 +96,7 @@ describe ManifestsPlugin do
 
           it "calls the command for all apps in the manifest" do
             uncalled_apps = ["foo", "bar"]
-            mock(wrapped).call(anything).twice do |inputs|
+            wrapped.should_receive(:call).with(anything).twice do |inputs|
               uncalled_apps.delete inputs.given[:app]
             end
 
@@ -114,10 +114,10 @@ describe ManifestsPlugin do
           let(:given_hash) { { :apps => ["x", "a"] } }
 
           it "passes through to the original command" do
-            mock(plugin).show_manifest_usage
+            plugin.should_receive(:show_manifest_usage)
 
             uncalled_apps = ["a", "x"]
-            mock(wrapped).call(anything).twice do |inputs|
+            wrapped.should_receive(:call).with(anything).twice do |inputs|
               uncalled_apps.delete inputs.given[:app]
             end
 
@@ -136,8 +136,8 @@ describe ManifestsPlugin do
           let(:given_hash) { { :apps => ["x", "y"] } }
 
           it "passes through to the original command" do
-            dont_allow(plugin).show_manifest_usage
-            mock(wrapped).call
+            wrapped.should_receive(:call)
+            plugin.should_not_receive(:show_manifest_usage)
             subject
           end
         end
@@ -148,7 +148,7 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "foo" } }
 
         it "calls the command with that app" do
-          mock(wrapped).call(anything) do |inputs|
+          wrapped.should_receive(:call).with(anything) do |inputs|
             expect(inputs.given[:app]).to eq "foo"
           end
 
@@ -161,7 +161,7 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "/abc/foo" } }
 
         it "calls the command with that app" do
-          mock(wrapped).call(anything) do |inputs|
+          wrapped.should_receive(:call).with(anything) do |inputs|
             expect(inputs.given[:app]).to eq "foo"
           end
 
@@ -172,13 +172,13 @@ describe ManifestsPlugin do
   end
 
   describe "#wrap_push" do
-    let(:wrapped) { mock! }
+    let(:wrapped) { double(:wrapped).as_null_object }
     let(:command) { Mothership.commands[:push] }
 
     subject { plugin.send(:wrap_push, wrapped, inputs) }
 
     before do
-      stub(plugin).show_manifest_usage
+      plugin.stub(:show_manifest_usage)
     end
 
     context "with a manifest" do
@@ -209,7 +209,7 @@ describe ManifestsPlugin do
               let(:given_hash) { { :name => "a", :instances => "100" } }
 
               it "rebases their inputs on the manifest's values" do
-                mock(wrapped).call(anything) do |inputs|
+                wrapped.should_receive(:call).with(anything) do |inputs|
                   expect(inputs.given).to eq(
                     :name => "a", :path => "/abc/a", :instances => "100", :memory => "128M")
                 end
@@ -221,7 +221,7 @@ describe ManifestsPlugin do
 
           context "and the app does NOT exist" do
             it "pushes a new app with the inputs from the manifest" do
-              mock(wrapped).call(anything) do |inputs|
+              wrapped.should_receive(:call).with(anything) do |inputs|
                 expect(inputs.given).to eq(
                   :name => "a", :path => "/abc/a", :instances => "200", :memory => "128M")
               end
@@ -263,7 +263,7 @@ describe ManifestsPlugin do
 
           it "pushes the found apps" do
             pushed_apps = []
-            mock(wrapped).call(anything).twice do |inputs|
+            wrapped.should_receive(:call).with(anything).twice do |inputs|
               pushed_apps << inputs[:name]
             end
 
@@ -284,12 +284,12 @@ describe ManifestsPlugin do
     end
 
     context "without a manifest" do
-      let(:app) { mock! }
+      let(:app) { double(:app).as_null_object }
       let(:manifest) { nil }
 
       it "asks to save the manifest when uploading the application" do
         mock_ask("Save configuration?", :default => false)
-        stub(wrapped).call { plugin.filter(:push_app, app) }
+        wrapped.stub(:call) { plugin.filter(:push_app, app) }
         subject
       end
     end
@@ -298,7 +298,7 @@ describe ManifestsPlugin do
   describe "#push_input_for" do
     context "with an existing app" do
       before do
-        stub(plugin).from_manifest { "PATH" }
+        plugin.stub(:from_manifest) { "PATH" }
         app.changes.clear
       end
 
@@ -320,14 +320,14 @@ describe ManifestsPlugin do
           end
 
           it "does not ask to set --reset" do
-            dont_allow(plugin).warn_reset_changes
+            plugin.should_not_receive(:warn_reset_changes)
             subject
           end
         end
 
         context "without changes" do
           it "does not ask to set --reset" do
-            dont_allow(plugin).warn_reset_changes
+            plugin.should_not_receive(:warn_reset_changes)
             subject
           end
         end
@@ -340,19 +340,19 @@ describe ManifestsPlugin do
           let(:manifest_memory) { "128M" }
 
           it "asks user to provide --reset" do
-            mock(plugin).warn_reset_changes
+            plugin.should_receive(:warn_reset_changes)
             subject
           end
 
           it "does not apply changes" do
-            stub(plugin).warn_reset_changes
+            plugin.stub(:warn_reset_changes)
             subject[:memory].should == nil
           end
         end
 
         context "without changes" do
           it "does not ask to set --reset" do
-            dont_allow(plugin).warn_reset_changes
+            plugin.should_not_receive(:warn_reset_changes)
             subject
           end
         end