cf 1.1.4 → 2.0.0

data/lib/cf/cli/start/login.rb

@@ -35,8 +35,11 @@ module CF::Start
       authenticated = false
       failed = false
       remaining_attempts = 3
+
       until authenticated || remaining_attempts <= 0
         remaining_attempts -= 1
+        failed = false
+
         unless force?
           ask_prompts(credentials, prompts)
         end

data/lib/cf/version.rb

@@ -1,3 +1,3 @@
 module CF
-  VERSION = "1.1.4".freeze
+  VERSION = "2.0.0".freeze
 end

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 require "cf/cli/app/base"
 
 describe CF::App::Base do
-  describe '#human_size' do
+  describe "#human_size" do
     let(:base) { CF::App::Base.new }
 
     it { base.human_size(1_023).should == "1023.0B" }

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

@@ -1,174 +1,195 @@
-require 'spec_helper'
+require "spec_helper"
 require "cf/cli/app/delete"
 
-describe CF::App::Delete do
-  let(:global) { { :color => false, :quiet => true } }
-  let(:inputs) { {} }
-  let(:given) { {} }
-  let(:client) { fake_client }
-  let(:app) {}
-  let(:new_name) { "some-new-name" }
-
-  before do
-    CF::CLI.any_instance.stub(:client).and_return(client)
-    CF::CLI.any_instance.stub(:precondition).and_return(nil)
-  end
+module CF
+  module App
+    describe Delete do
+      let(:global) { {:color => false, :quiet => true} }
+      let(:inputs) { {} }
+      let(:given) { {} }
+      let(:client) { build(:client) }
+
+      before do
+        CF::CLI.any_instance.stub(:client).and_return(client)
+        CF::CLI.any_instance.stub(:precondition).and_return(nil)
+      end
 
-  subject { Mothership.new.invoke(:delete, inputs, given, global) }
+      subject { Mothership.new.invoke(:delete, inputs, given, global) }
 
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:delete] }
+      describe "metadata" do
+        let(:command) { Mothership.commands[:delete] }
 
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Delete an application" }
-      it { expect(Mothership::Help.group(:apps, :manage)).to include(subject) }
-    end
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Delete 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
-      subject { command.arguments }
-      it 'has the correct argument order' do
-        should eq([{ :type => :splat, :value => nil, :name => :apps }])
+        describe "arguments" do
+          subject { command.arguments }
+          it "has the correct argument order" do
+            should eq([{:type => :splat, :value => nil, :name => :apps}])
+          end
+        end
       end
-    end
-  end
 
-  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 "when there are no apps" do
+        before do
+          client.stub(:apps).and_return([])
+        end
 
-    context 'and an app is not given' do
-      it { expect { subject }.to raise_error(CF::UserError, "No applications.") }
-    end
-  end
+        context "and an app is given" do
+          let(:given) { {:app => "some-app"} }
 
-  context 'when there are apps' do
-    let(:client) { fake_client(:apps => apps) }
-    let(:apps) { [basic_app, app_with_orphans, app_without_orphans] }
-    let(:service_1) { fake :service_instance }
-    let(:service_2) { fake :service_instance }
-    let(:basic_app) { fake(:app, :name => "basic_app") }
-    let(:app_with_orphans) {
-      fake :app,
-        :name => "app_with_orphans",
-        :service_bindings => [
-          fake(:service_binding, :service_instance => service_1),
-          fake(:service_binding, :service_instance => service_2)
-        ]
-    }
-    let(:app_without_orphans) {
-      fake :app,
-        :name => "app_without_orphans",
-        :service_bindings => [
-          fake(:service_binding, :service_instance => service_1)
-        ]
-    }
-
-    context 'and no app is given' do
-      it 'asks for the app' do
-        mock_ask("Delete which application?", anything) { basic_app }
-        stub_ask { true }
-        basic_app.stub(:delete!)
-        subject
+          it { expect { subject }.to raise_error(CF::UserError, "Unknown app 'some-app'.") }
+        end
+
+        context "and an app is not given" do
+          it { expect { subject }.to raise_error(CF::UserError, "No applications.") }
+        end
       end
-    end
 
-    context 'and a basic app is given' do
-      let(:deleted_app) { basic_app }
-      let(:given) { { :app => deleted_app.name } }
+      context "when there are apps" do
+        let(:service_1) { build(:service_instance, :name => "service-instance-name-1") }
+        let(:service_2) { build(:service_instance, :name => "service-instance-name-2") }
+
+        let(:service_binding_1) { build(:service_binding, :service_instance => service_1) }
+        let(:service_binding_2) { build(:service_binding, :service_instance => service_2) }
+
+        let(:basic_app) { build(:app, :name => "basic-app-name", :guid => "basic-app-guid-1") }
+
+        let(:app_with_orphans) {
+          build(:app,
+            :name => "app_with_orphans",
+            :service_bindings => [service_binding_1, service_binding_2]
+          )
+        }
+        let(:app_without_orphans) {
+          build(:app,
+            :name => "app_without_orphans",
+            :service_bindings => [service_binding_1]
+          )
+        }
+
+        let(:apps) { [basic_app, app_with_orphans, app_without_orphans] }
+
+        before do
+          basic_app.stub(:service_bindings).and_return([])
+          client.stub(:apps).and_return(apps)
+        end
+
+        context "and no app is given" do
+          it "asks for the app" do
+            basic_app.stub(:delete!)
+
+            should_ask("Delete which application?", anything) { basic_app }
+            stub_ask { true }
 
-      context 'and it asks for confirmation' do
-        context 'and the user answers no' do
-          it 'does not delete the application' do
-            mock_ask("Really delete #{deleted_app.name}?", anything) { false }
-            deleted_app.should_not_receive(:delete!)
             subject
           end
         end
 
-        context 'and the user answers yes' do
-          it 'deletes the application' do
-            mock_ask("Really delete #{deleted_app.name}?", anything) { true }
-            deleted_app.should_receive(:delete!)
-            subject
+        context "and a basic app is given" do
+          let(:deleted_app) { basic_app }
+          let(:given) { {:app => deleted_app.name} }
+
+          context "and it asks for confirmation" do
+            context "and the user answers no" do
+              it "does not delete the application" do
+                should_ask("Really delete #{deleted_app.name}?", anything) { false }
+                deleted_app.should_not_receive(:delete!)
+                subject
+              end
+            end
+
+            context "and the user answers yes" do
+              it "deletes the application" do
+                should_ask("Really delete #{deleted_app.name}?", anything) { true }
+                deleted_app.should_receive(:delete!)
+                subject
+              end
+            end
           end
-        end
-      end
 
-      context 'and --force is given' do
-        let(:global) { { :force => true, :color => false, :quiet => true } }
+          context "and --force is given" do
+            let(:global) { {:force => true, :color => false, :quiet => true} }
 
-        it 'deletes the application without asking to confirm' do
-          dont_allow_ask
-          deleted_app.should_receive(:delete!)
-          subject
+            it "deletes the application without asking to confirm" do
+              dont_allow_ask
+              deleted_app.should_receive(:delete!)
+              subject
+            end
+          end
         end
-      end
-    end
 
-    context 'and an app with orphaned services is given' do
-      let(:deleted_app) { app_with_orphans }
-      let(:inputs) { { :app => deleted_app } }
+        context "and an app with orphaned services is given" do
+          let(:deleted_app) { app_with_orphans }
+          let(:inputs) { {:app => deleted_app} }
 
-      context 'and it asks for confirmation' do
-        context 'and the user answers yes' do
-          it 'asks to delete orphaned services' do
-            stub_ask("Really delete #{deleted_app.name}?", anything) { true }
-            deleted_app.stub(:delete!)
+          before do
+            app_with_orphans.stub(:service_bindings).and_return([service_binding_1, service_binding_2])
+            app_with_orphans.stub(:service_instances).and_return([service_1, service_2])
+          end
 
-            service_2.stub(:invalidate!)
+          context "and it asks for confirmation" do
+            context "and the user answers yes" do
+              it "asks to delete orphaned services" do
+                stub_ask("Really delete #{deleted_app.name}?", anything) { true }
+                deleted_app.stub(:delete!)
 
-            mock_ask("Delete orphaned service #{service_2.name}?", anything) { true }
+                service_2.stub(:invalidate!)
 
-            CF::App::Delete.any_instance.should_receive(:invoke).with(:delete_service, :service => service_2, :really => true)
+                should_ask("Delete orphaned service #{service_2.name}?", anything) { true }
 
-            subject
-          end
-        end
+                CF::App::Delete.any_instance.should_receive(:invoke).with(:delete_service, :service => service_2, :really => true)
 
-        context 'and the user answers no' do
-          it 'does not ask to delete orphaned serivces, or delete them' do
-            stub_ask("Really delete #{deleted_app.name}?", anything) { false }
-            deleted_app.should_not_receive(:delete!)
+                subject
+              end
+            end
 
-            service_2.stub(:invalidate!)
+            context "and the user answers no" do
+              it "does not ask to delete orphaned serivces, or delete them" do
+                stub_ask("Really delete #{deleted_app.name}?", anything) { false }
+                deleted_app.should_not_receive(:delete!)
 
-            dont_allow_ask("Delete orphaned service #{service_2.name}?")
+                service_2.stub(:invalidate!)
 
-            CF::App::Delete.any_instance.should_not_receive(:invoke).with(:delete_service, anything)
+                dont_allow_ask("Delete orphaned service #{service_2.name}?")
 
-            subject
+                CF::App::Delete.any_instance.should_not_receive(:invoke).with(:delete_service, anything)
+
+                subject
+              end
+            end
           end
-        end
-      end
 
-      context 'and --force is given' do
-        let(:global) { { :force => true, :color => false, :quiet => true } }
+          context "and --force is given" do
+            let(:global) { {:force => true, :color => false, :quiet => true} }
 
-        it 'does not delete orphaned services' do
-          dont_allow_ask
-          deleted_app.stub(:delete!)
+            it "does not delete orphaned services" do
+              dont_allow_ask
+              deleted_app.stub(:delete!)
 
-          CF::App::Delete.any_instance.should_not_receive(:invoke).with(:delete_service, anything)
+              CF::App::Delete.any_instance.should_not_receive(:invoke).with(:delete_service, anything)
 
-          subject
-        end
-      end
+              subject
+            end
+          end
 
-      context 'and --delete-orphaned is given' do
-        let(:inputs) { { :app => deleted_app, :delete_orphaned => true } }
+          context "and --delete-orphaned is given" do
+            let(:inputs) { {:app => deleted_app, :delete_orphaned => true} }
 
-        it 'deletes the orphaned services' do
-          stub_ask("Really delete #{deleted_app.name}?", anything) { true }
-          deleted_app.stub(:delete!)
+            it "deletes the orphaned services" do
+              stub_ask("Really delete #{deleted_app.name}?", anything) { true }
+              deleted_app.stub(:delete!)
 
-          CF::App::Delete.any_instance.should_receive(:invoke).with(:delete_service, :service => service_2, :really => true)
+              CF::App::Delete.any_instance.should_receive(:invoke).with(:delete_service, :service => service_2, :really => true)
 
-          subject
+              subject
+            end
+          end
         end
       end
     end

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

@@ -1,64 +1,69 @@
-require 'spec_helper'
-require 'stringio'
+require "spec_helper"
+require "stringio"
 
-describe CF::App::Stats do
-  let(:global) { { :color => false } }
-  let(:inputs) { { :app => apps[0] } }
-  let(:given) { {} }
-  let(:client) { fake_client(:apps => apps) }
-  let(:apps) { [fake(:app, :name => "basic_app")] }
-  let(:time) { Time.local(2012, 11, 1, 2, 30) }
+module CF
+  module App
+    describe Stats do
+      let(:global) { {:color => false} }
+      let(:inputs) { {:app => apps[0]} }
+      let(:given) { {} }
+      let(:client) { build(:client) }
+      let(:apps) { [build(:app, :client => client, :name => "basic-app-name")] }
+      let(:time) { Time.local(2012, 11, 1, 2, 30) }
 
-  before do
-    CF::CLI.any_instance.stub(:client).and_return(client)
-    CF::CLI.any_instance.stub(:precondition).and_return(nil)
+      before do
+        client.stub(:apps).and_return(apps)
+        CF::CLI.any_instance.stub(:client).and_return(client)
+        CF::CLI.any_instance.stub(:precondition).and_return(nil)
 
-    client.base.stub(:instances).with(anything) do
-      {
-        "12" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
-        "1" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
-        "2" => {:state => "STARTED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"}
-      }
-    end
-  end
+        client.base.stub(:instances).with(anything) do
+          {
+            "12" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
+            "1" => {:state => "STOPPED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"},
+            "2" => {:state => "STARTED", :since => time.to_i, :debug_ip => "foo", :debug_port => "bar", :console_ip => "baz", :console_port => "qux"}
+          }
+        end
+      end
 
-  subject do
-    capture_output do
-      Mothership.new.invoke(:instances, inputs, given, global)
-    end
-  end
+      subject do
+        capture_output do
+          Mothership.new.invoke(:instances, inputs, given, global)
+        end
+      end
 
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:instances] }
+      describe "metadata" do
+        let(:command) { Mothership.commands[:instances] }
 
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "List an app's instances" }
-      it { expect(Mothership::Help.group(:apps, :info)).to include(subject) }
-    end
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "List an app's instances" }
+          it { expect(Mothership::Help.group(:apps, :info)).to include(subject) }
+        end
 
-    include_examples 'inputs must have descriptions'
+        include_examples "inputs must have descriptions"
 
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'has no arguments' do
-        should eq([{:type=>:splat, :value=>nil, :name=>:apps}])
+        describe "arguments" do
+          subject { command.arguments }
+          it "has no arguments" do
+            should eq([{:type => :splat, :value => nil, :name => :apps}])
+          end
+        end
       end
-    end
-  end
 
-  it 'prints out the instances in the correct order' do
-    subject
-    expect(output).to say("instance #1")
-    expect(output).to say("instance #2")
-    expect(output).to say("instance #12")
-  end
+      it "prints out the instances in the correct order" do
+        subject
+        expect(output).to say("instance #1")
+        expect(output).to say("instance #2")
+        expect(output).to say("instance #12")
+      end
 
-  it 'prints out one of the instances correctly' do
-    subject
-    expect(output).to say("instance #2: started")
-    expect(output).to say("  started: #{time.strftime("%F %r")}")
-    expect(output).to say("  debugger: port bar at foo")
-    expect(output).to say("  console: port qux at baz")
+      it "prints out one of the instances correctly" do
+        subject
+        expect(output).to say("instance #2: started")
+        expect(output).to say("  started: #{time.strftime("%F %r")}")
+        expect(output).to say("  debugger: port bar at foo")
+        expect(output).to say("  console: port qux at baz")
+      end
+    end
   end
 end