cf 1.1.3.rc1 → 1.1.4

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

@@ -1,5 +1,4 @@
-require 'spec_helper'
-require "cf/cli/app/rename"
+require "spec_helper"
 
 describe CF::App::Rename do
   let(:global) { { :color => false, :quiet => true } }
@@ -10,28 +9,26 @@ describe CF::App::Rename do
   let(:new_name) { "some-new-name" }
 
   before do
-    any_instance_of(CF::CLI) do |cli|
-      stub(cli).client { client }
-      stub(cli).precondition { nil }
-    end
+    CF::CLI.any_instance.stub(:client).and_return(client)
+    CF::CLI.any_instance.stub(:precondition).and_return(nil)
   end
 
   subject { Mothership.new.invoke(:rename, inputs, given, global) }
 
-  describe 'metadata' do
+  describe "metadata" do
     let(:command) { Mothership.commands[:rename] }
 
-    describe 'command' do
+    describe "command" do
       subject { command }
       its(:description) { should eq "Rename an application" }
       it { expect(Mothership::Help.group(:apps, :manage)).to include(subject) }
     end
 
-    include_examples 'inputs must have descriptions'
+    include_examples "inputs must have descriptions"
 
-    describe 'arguments' do
+    describe "arguments" do
       subject { command.arguments }
-      it 'has the correct argument order' do
+      it "has the correct argument order" do
         should eq([
           { :type => :optional, :value => nil, :name => :app },
           { :type => :optional, :value => nil, :name => :name }
@@ -40,62 +37,62 @@ describe CF::App::Rename do
     end
   end
 
-  context 'when there are no apps' do
-    context 'and an app is given' do
+  context "when there are no apps" do
+    context "and an app is given" do
       let(:given) { { :app => "some-app" } }
       it { expect { subject }.to raise_error(CF::UserError, "Unknown app 'some-app'.") }
     end
 
-    context 'and an app is not given' do
+    context "and an app is not given" do
       it { expect { subject }.to raise_error(CF::UserError, "No applications.") }
     end
   end
 
-  context 'when there are apps' do
+  context "when there are apps" do
     let(:client) { fake_client(:apps => apps) }
     let(:apps) { fake_list(:app, 2) }
     let(:renamed_app) { apps.first }
 
-    context 'when the defaults are used' do
-      it 'asks for the app and new name and renames' do
+    context "when the defaults are used" do
+      it "asks for the app and new name and renames" do
         mock_ask("Rename which application?", anything) { renamed_app }
         mock_ask("New name") { new_name }
-        mock(renamed_app).name=(new_name)
-        mock(renamed_app).update!
+        renamed_app.should_receive(:name=).with(new_name)
+        renamed_app.should_receive(:update!)
         subject
       end
     end
 
-    context 'when no name is provided, but a app is' do
+    context "when no name is provided, but a app is" do
       let(:given) { { :app => renamed_app.name } }
 
-      it 'asks for the new name and renames' do
+      it "asks for the new name and renames" do
         dont_allow_ask("Rename which application?", anything)
         mock_ask("New name") { new_name }
-        mock(renamed_app).name=(new_name)
-        mock(renamed_app).update!
+        renamed_app.should_receive(:name=).with(new_name)
+        renamed_app.should_receive(:update!)
         subject
       end
     end
 
-    context 'when an app is provided and a name' do
+    context "when an app is provided and a name" do
       let(:inputs) { { :app => renamed_app, :name => new_name } }
 
-      it 'renames the app' do
-        mock(renamed_app).update!
+      it "renames the app" do
+        renamed_app.should_receive(:update!)
         subject
       end
 
-      it 'displays the progress' do
+      it "displays the progress" do
         mock_with_progress("Renaming to #{new_name}")
-        mock(renamed_app).update!
+        renamed_app.should_receive(:update!)
 
         subject
       end
 
-      context 'and the name already exists' do
-        it 'fails' do
-          mock(renamed_app).update! { raise CFoundry::AppNameTaken.new("Bad Name", 404) }
+      context "and the name already exists" do
+        it "fails" do
+          renamed_app.should_receive(:update!) { raise CFoundry::AppNameTaken.new("Bad Name", 404) }
           expect { subject }.to raise_error(CFoundry::AppNameTaken)
         end
       end

data/spec/cf/cli/app/scale_spec.rb

@@ -1,55 +1,58 @@
 require "spec_helper"
-require "webmock/rspec"
 
-describe CF::App::Scale do
-  before do
-    stub_client_and_precondition
-  end
-
-  let(:client) { fake_client :apps => [app] }
-
-  context "when the --disk flag is given" do
-    let(:before_value) { 512 }
-    let(:app) { fake :app, :disk_quota => before_value }
-
-    subject { cf %W[scale #{app.name} --disk 1G] }
+module CF
+  module App
+    describe Scale do
+      before do
+        stub_client_and_precondition
+      end
 
-    it "changes the application's disk quota" do
-      mock(app).update!
-      expect { subject }.to change(app, :disk_quota).from(before_value).to(1024)
-    end
-  end
+      let(:client) { fake_client :apps => [app] }
 
-  context "when the --memory flag is given" do
-    let(:before_value) { 512 }
-    let(:app) { fake :app, :memory => before_value }
+      context "when the --disk flag is given" do
+        let(:before_value) { 512 }
+        let(:app) { fake :app, :disk_quota => before_value }
 
-    subject { cf %W[scale #{app.name} --memory 1G] }
+        subject { cf %W[scale #{app.name} --disk 1G] }
 
-    it "changes the application's memory" do
-      mock(app).update!
-      expect { subject }.to change(app, :memory).from(before_value).to(1024)
-    end
+        it "changes the application's disk quota" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :disk_quota).from(before_value).to(1024)
+        end
+      end
 
-    context "if --restart is true" do
-      it "restarts the application" do
-        stub(app).update!
-        stub(app).started? { true }
-        mock_invoke :restart, :app => app
-        subject
+      context "when the --memory flag is given" do
+        let(:before_value) { 512 }
+        let(:app) { fake :app, :memory => before_value }
+
+        subject { cf %W[scale #{app.name} --memory 1G] }
+
+        it "changes the application's memory" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :memory).from(before_value).to(1024)
+        end
+
+        context "if --restart is true" do
+          it "restarts the application" do
+            app.stub(:update!)
+            app.stub(:started?) { true }
+            mock_invoke :restart, :app => app
+            subject
+          end
+        end
       end
-    end
-  end
 
-  context "when the --instances flag is given" do
-    let(:before_value) { 3 }
-    let(:app) { fake :app, :total_instances => before_value }
+      context "when the --instances flag is given" do
+        let(:before_value) { 3 }
+        let(:app) { fake :app, :total_instances => before_value }
 
-    subject { cf %W[scale #{app.name} --instances 5] }
+        subject { cf %W[scale #{app.name} --instances 5] }
 
-    it "changes the application's number of instances" do
-      mock(app).update!
-      expect { subject }.to change(app, :total_instances).from(before_value).to(5)
+        it "changes the application's number of instances" do
+          app.should_receive(:update!)
+          expect { subject }.to change(app, :total_instances).from(before_value).to(5)
+        end
+      end
     end
   end
 end

data/spec/cf/cli/app/start_spec.rb

@@ -1,242 +1,243 @@
 require "spec_helper"
-require "webmock/rspec"
 
-describe CF::App::Start do
-  before do
-    stub_client_and_precondition
-  end
-
-  let(:client) { fake_client :apps => [app] }
-  let(:app) { fake :app }
-
-  subject { cf %W[start #{app.name}] }
-
-  context "with an app that's already started" do
-    let(:app) { fake :app, :state => "STARTED" }
-
-    it "skips starting the application" do
-      dont_allow(app).start!
-      subject
-    end
-
-    it "says the app is already started" do
-      subject
-      expect(error_output).to say("Application #{app.name} is already started.")
-    end
-  end
-
-  context "with an app that's NOT already started" do
-    def self.it_says_application_is_starting
-      it "says that it's starting the application" do
-        subject
-        expect(output).to say("Starting #{app.name}... OK")
+module CF
+  module App
+    describe Start do
+      before do
+        stub_client_and_precondition
       end
-    end
 
-    def self.it_prints_log_progress
-      it "prints out the log progress" do
-        subject
-        expect(output).to say(log_text)
-      end
-    end
+      let(:client) { fake_client :apps => [app] }
+      let(:app) { fake :app }
 
-    def self.it_does_not_print_log_progress
-      it "does not print the log progress" do
-        subject
-        expect(output).to_not say(log_text)
-      end
-    end
+      subject { cf %W[start #{app.name}] }
 
-    def self.it_waits_for_application_to_become_healthy
-      describe "waits for application to become healthy" do
-        let(:app) { fake :app, :total_instances => 2 }
+      context "with an app that's already started" do
+        let(:app) { fake :app, :state => "STARTED" }
 
-        def after_sleep
-          any_instance_of described_class do |cli|
-            stub(cli).sleep { yield }
-          end
+        it "skips starting the application" do
+          app.should_not_receive(:start!)
+          subject
         end
 
-        before do
-          stub(app).instances do
-            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
-              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
-            ]
-          end
-
-          after_sleep do
-            stub(app).instances { final_instances }
-          end
+        it "says the app is already started" do
+          subject
+          expect(error_output).to say("Application #{app.name} is already started.")
         end
+      end
 
-        context "when all instances become running" do
-          let(:final_instances) do
-            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
-              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
-            ]
-          end
-
-          it "says app is started" do
+      context "with an app that's NOT already started" do
+        def self.it_says_application_is_starting
+          it "says that it's starting the application" do
             subject
-            expect(output).to say("Checking #{app.name}...")
-            expect(output).to say("1 running, 1 down")
-            expect(output).to say("2 running")
+            expect(output).to say("Starting #{app.name}... OK")
           end
         end
 
-        context "staging fails" do
-          before do
-            stub(app).instances { raise CFoundry::StagingError.new("Failed to stage", 170001, nil, nil) }
-          end
-
-          it "says the app failed to stage" do
+        def self.it_prints_log_progress
+          it "prints out the log progress" do
             subject
-            expect(output).to say("Checking #{app.name}...")
-            expect(error_output).to say("Application failed to stage")
-            expect(output).to_not say(/\d (running|down|flapping)/)
+            expect(output).to say(log_text)
           end
         end
 
-        context "staging has not completed" do
-          let(:final_instances) do
-            [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
-              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
-            ]
-          end
-
-          before do
-            stub(app).instances { raise CFoundry::NotStaged.new("Staging is pending", 170002, nil, nil) }
+        def self.it_does_not_print_log_progress
+          it "does not print the log progress" do
+            subject
+            expect(output).to_not say(log_text)
           end
+        end
 
-          it "keeps polling" do
-            subject
-            expect(output).to say("Checking #{app.name}...")
-            expect(output).to say("Staging in progress...")
-            expect(output).to say("2 running")
+        def self.it_waits_for_application_to_become_healthy
+          describe "waits for application to become healthy" do
+            let(:app) { fake :app, :total_instances => 2 }
+
+            def after_sleep
+              described_class.any_instance.stub(:sleep) { yield }
+            end
+
+            before do
+              app.stub(:instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+                ]
+              end
+
+              after_sleep do
+                app.stub(:instances) { final_instances }
+              end
+            end
+
+            context "when all instances become running" do
+              let(:final_instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+                ]
+              end
+
+              it "says app is started" do
+                subject
+                expect(output).to say("Checking #{app.name}...")
+                expect(output).to say("1 running, 1 down")
+                expect(output).to say("2 running")
+              end
+            end
+
+            context "staging fails" do
+              before do
+                app.stub(:instances) { raise CFoundry::StagingError.new("Failed to stage", 170001, nil, nil) }
+              end
+
+              it "says the app failed to stage" do
+                subject
+                expect(output).to say("Checking #{app.name}...")
+                expect(error_output).to say("Application failed to stage")
+                expect(output).to_not say(/\d (running|down|flapping)/)
+              end
+            end
+
+            context "staging has not completed" do
+              let(:final_instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
+                ]
+              end
+
+              before do
+                app.stub(:instances) { raise CFoundry::NotStaged.new("Staging is pending", 170002, nil, nil) }
+              end
+
+              it "keeps polling" do
+                subject
+                expect(output).to say("Checking #{app.name}...")
+                expect(output).to say("Staging in progress...")
+                expect(output).to say("2 running")
+              end
+            end
+
+            context "when any instance becomes flapping" do
+              let(:final_instances) do
+                [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
+                  CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "STARTING")
+                ]
+              end
+
+              it "says app failed to start" do
+                subject
+                expect(output).to say("Checking #{app.name}...")
+                expect(output).to say("1 running, 1 down")
+                expect(output).to say("1 starting, 1 flapping")
+                expect(error_output).to say("Application failed to start")
+              end
+            end
           end
         end
 
-        context "when any instance becomes flapping" do
-          let(:final_instances) do
-            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
-              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "STARTING")
-            ]
+        let(:log_url) { nil }
+
+        before do
+          app.stub(:invalidate!)
+          app.stub(:instances) do
+            [CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")]
           end
 
-          it "says app failed to start" do
-            subject
-            expect(output).to say("Checking #{app.name}...")
-            expect(output).to say("1 running, 1 down")
-            expect(output).to say("1 starting, 1 flapping")
-            expect(error_output).to say("Application failed to start")
+          app.should_receive(:start!).with(true) do |_, &blk|
+            app.state = "STARTED"
+            blk.call(log_url)
           end
         end
-      end
-    end
 
-    let(:log_url) { nil }
+        context "when progress log url is provided" do
+          let(:log_url) { "http://example.com/my-app-log" }
+          let(:log_text) { "Staging complete!" }
 
-    before do
-      stub(app).invalidate!
-      stub(app).instances do
-        [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING") ]
-      end
+          context "and progress log url is not available immediately" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 404, :body => "")
+            end
 
-      stub(app).start!(true) do |_, blk|
-        app.state = "STARTED"
-        blk.call(log_url)
-      end
-    end
-
-    context "when progress log url is provided" do
-      let(:log_url) { "http://example.com/my-app-log" }
-      let(:log_text) { "Staging complete!" }
-
-      context "and progress log url is not available immediately" do
-        before do
-          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
-            :status => 404, :body => "")
-        end
+            it_says_application_is_starting
+            it_does_not_print_log_progress
+            it_waits_for_application_to_become_healthy
+          end
 
-        it_says_application_is_starting
-        it_does_not_print_log_progress
-        it_waits_for_application_to_become_healthy
-      end
+          context "and progress log url becomes unavailable after some time" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 200, :body => log_text[0...5])
+              stub_request(:get, "#{log_url}&tail&tail_offset=5").to_return(
+                :status => 200, :body => log_text[5..-1])
+              stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+                :status => 404, :body => "")
+            end
+
+            it_says_application_is_starting
+            it_prints_log_progress
+            it_waits_for_application_to_become_healthy
+          end
 
-      context "and progress log url becomes unavailable after some time" do
-        before do
-          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
-            :status => 200, :body => log_text[0...5])
-          stub_request(:get, "#{log_url}&tail&tail_offset=5").to_return(
-            :status => 200, :body => log_text[5..-1])
-          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
-            :status => 404, :body => "")
+          context "and a request times out" do
+            before do
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :should_timeout => true)
+              stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
+                :status => 200, :body => log_text)
+              stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
+                :status => 404, :body => "")
+            end
+
+            it_says_application_is_starting
+            it_prints_log_progress
+            it_waits_for_application_to_become_healthy
+          end
         end
 
-        it_says_application_is_starting
-        it_prints_log_progress
-        it_waits_for_application_to_become_healthy
-      end
+        context "when progress log url is not provided" do
+          let(:log_url) { nil }
+          let(:log_text) { "Staging complete!" }
 
-      context "and a request times out" do
-        before do
-          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
-            :should_timeout => true)
-          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
-            :status => 200, :body => log_text)
-          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
-            :status => 404, :body => "")
+          it_says_application_is_starting
+          it_does_not_print_log_progress
+          it_waits_for_application_to_become_healthy
         end
 
-        it_says_application_is_starting
-        it_prints_log_progress
-        it_waits_for_application_to_become_healthy
-      end
-    end
-
-    context "when progress log url is not provided" do
-      let(:log_url) { nil }
-      let(:log_text) { "Staging complete!" }
-
-      it_says_application_is_starting
-      it_does_not_print_log_progress
-      it_waits_for_application_to_become_healthy
-    end
+        context "when a debug mode is given" do
+          let(:mode) { "foo" }
 
-    context "when a debug mode is given" do
-      let(:mode) { "foo" }
+          subject { cf %W[start #{app.name} -d #{mode}] }
 
-      subject { cf %W[start #{app.name} -d #{mode}] }
-
-      context "and the debug mode is different from the one already set" do
-        it "starts the app with the given debug mode" do
-          expect { subject }.to change { app.debug }.from(nil).to("foo")
-        end
-      end
+          context "and the debug mode is different from the one already set" do
+            it "starts the app with the given debug mode" do
+              expect { subject }.to change { app.debug }.from(nil).to("foo")
+            end
+          end
 
-      context "and the debug mode is the same as the one already set" do
-        let(:app) { fake :app, :debug => "foo" }
+          context "and the debug mode is the same as the one already set" do
+            let(:app) { fake :app, :debug => "foo" }
 
-        it "does not set the debug mode to anything different" do
-          dont_allow(app).debug = anything
-          subject
-        end
-      end
+            it "does not set the debug mode to anything different" do
+              app.should_not_receive(:debug).with(anything)
+              subject
+            end
+          end
 
-      context "and the mode is given as 'none'" do
-        let(:app) { fake :app, :debug => "foo" }
-        let(:mode) { "none" }
+          context "and the mode is given as 'none'" do
+            let(:app) { fake :app, :debug => "foo" }
+            let(:mode) { "none" }
 
-        it "removes the debug mode" do
-          expect { subject }.to change { app.debug }.from("foo").to(nil)
-        end
-      end
+            it "removes the debug mode" do
+              expect { subject }.to change { app.debug }.from("foo").to(nil)
+            end
+          end
 
-      context "and an empty mode is given" do
-        let(:mode) { "" }
+          context "and an empty mode is given" do
+            let(:mode) { "" }
 
-        it "sets debug to 'run'" do
-          expect { subject }.to change { app.debug }.from(nil).to("run")
+            it "sets debug to 'run'" do
+              expect { subject }.to change { app.debug }.from(nil).to("run")
+            end
+          end
         end
       end
     end