cf 1.1.3.rc1 → 1.1.4

data/spec/cf/cli/user/register_spec.rb

@@ -1,143 +1,144 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::User::Register do
-  before do
-    stub_client_and_precondition
-  end
+module CF
+  module User
+    describe Register do
+      let(:client) { fake_client }
 
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:register] }
+      before do
+        stub_client_and_precondition
+      end
 
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Create a user and log in" }
-      it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
-    end
+      describe "metadata" do
+        let(:command) { Mothership.commands[:register] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Create a user and log in" }
+          it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+        end
 
-    include_examples 'inputs must have descriptions'
+        include_examples "inputs must have descriptions"
 
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'have the correct commands' do
-        should eq [
-          {:type => :optional, :value => nil, :name => :email}
-        ]
+        describe "arguments" do
+          subject { command.arguments }
+          it "have the correct commands" do
+            should eq [
+              {:type => :optional, :value => nil, :name => :email}
+            ]
+          end
+        end
       end
-    end
-  end
 
-  describe '#register' do
-    let(:client) { fake_client }
-    let(:email) { 'a@b.com' }
-    let(:password) { 'password' }
-    let(:verify_password) { password }
-    let(:force) { false }
-    let(:login) { false }
-    let(:score) { :strong }
-
-    before do
-      stub(client).register
-      stub(client).base.stub!.password_score(password) { score }
-    end
+      describe "#register" do
+        let(:email) { "a@b.com" }
+        let(:password) { "password" }
+        let(:verify_password) { password }
+        let(:force) { false }
+        let(:login) { false }
+        let(:score) { :strong }
+
+        before do
+          client.stub(:register)
+          client.base.stub(:password_score) { score }
+        end
 
-    subject { cf %W[register --email #{email} --password #{password} --verify #{verify_password} --#{bool_flag(:login)} --#{bool_flag(:force)}] }
+        subject { cf %W[register --email #{email} --password #{password} --verify #{verify_password} --#{bool_flag(:login)} --#{bool_flag(:force)}] }
 
-    context 'when the passwords dont match' do
-      let(:verify_password) { "other_password" }
+        context "when the passwords dont match" do
+          let(:verify_password) { "other_password" }
 
-      it { should eq 1 }
+          it { should eq 1 }
 
-      it 'fails' do
-        subject
-        expect(error_output).to say("Passwords do not match.")
-      end
+          it "fails" do
+            subject
+            expect(error_output).to say("Passwords do not match.")
+          end
 
-      it "doesn't print out the score" do
-        subject
-        expect(output).to_not say("strength")
-      end
+          it "doesn't print out the score" do
+            subject
+            expect(output).to_not say("strength")
+          end
 
-      it "doesn't log in or register" do
-        dont_allow(client).register
-        dont_allow_invoke
-        subject
-      end
+          it "doesn't log in or register" do
+            client.should_not_receive(:register)
+            dont_allow_invoke
+            subject
+          end
 
-      context 'and the force flag is passed' do
-        let(:force) { true }
+          context "and the force flag is passed" do
+            let(:force) { true }
 
-        it "doesn't verify the password" do
-          mock(client).register(email, password)
-          subject
-          expect(error_output).to_not say("Passwords do not match.")
+            it "doesn't verify the password" do
+              client.should_receive(:register).with(email, password)
+              subject
+              expect(error_output).to_not say("Passwords do not match.")
+            end
+          end
         end
-      end
-    end
 
-    context 'when the password is good or strong' do
-      it { should eq 0 }
+        context "when the password is good or strong" do
+          it { should eq 0 }
 
-      it 'prints out the password score' do
-        subject
-        expect(stdout.string).to include "Your password strength is: strong"
-      end
+          it "prints out the password score" do
+            subject
+            expect(stdout.string).to include "Your password strength is: strong"
+          end
 
-      it 'registers the user' do
-        mock(client).register(email, password)
-        subject
-      end
+          it "registers the user" do
+            client.should_receive(:register).with(email, password)
+            subject
+          end
 
-      context 'and the login flag is true' do
-        let(:login) { true }
+          context "and the login flag is true" do
+            let(:login) { true }
 
-        it 'logs in' do
-          any_instance_of(described_class) do |register|
-            mock(register).invoke(:login, :username => email, :password => password)
+            it "logs in" do
+              described_class.any_instance.should_receive(:invoke).with(:login, :username => email, :password => password)
+              subject
+            end
           end
-          subject
-        end
-      end
 
-      context 'and the login flag is false' do
-        it "doesn't log in" do
-          any_instance_of(described_class) do |register|
-            dont_allow(register).invoke(:login, :username => email, :password => password)
+          context "and the login flag is false" do
+            it "doesn't log in" do
+              described_class.any_instance.should_not_receive(:invoke)
+              subject
+            end
           end
-          subject
         end
-      end
-    end
 
-    context 'when the password is weak' do
-      let(:score) { :weak }
-      let(:login) { true }
+        context "when the password is weak" do
+          let(:score) { :weak }
+          let(:login) { true }
 
-      it { should eq 1 }
+          it { should eq 1 }
 
-      it 'prints out the password score' do
-        subject
-        expect(error_output).to say("Your password strength is: weak")
-      end
+          it "prints out the password score" do
+            subject
+            expect(error_output).to say("Your password strength is: weak")
+          end
 
-      it "doesn't register" do
-        dont_allow(client).register(email, password)
-        subject
-      end
+          it "doesn't register" do
+            client.should_not_receive(:register).with(email, password)
+            subject
+          end
 
-      it "doesn't log in" do
-        dont_allow_invoke :login
-        subject
-      end
-    end
+          it "doesn't log in" do
+            dont_allow_invoke :login
+            subject
+          end
+        end
 
-    context 'when arguments are not passed in the command line' do
-      subject { cf %W[register --no-force --no-login] }
+        context "when arguments are not passed in the command line" do
+          subject { cf %W[register --no-force --no-login] }
 
-      it 'asks for the email, password and confirm password' do
-        mock_ask("Email") { email }
-        mock_ask("Password", anything) { password }
-        mock_ask("Confirm Password", anything) { verify_password }
-        subject
+          it "asks for the email, password and confirm password" do
+            mock_ask("Email") { email }
+            mock_ask("Password", anything) { password }
+            mock_ask("Confirm Password", anything) { verify_password }
+            subject
+          end
+        end
       end
     end
   end

data/spec/cf/cli_spec.rb

@@ -1,446 +1,441 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::CLI do
-  let(:context) { CF::CLI.new }
-  let(:command) { nil }
+module CF
+  describe CLI do
+    let(:context) { CF::CLI.new }
+    let(:command) { nil }
 
-  let(:fake_home_dir) { nil }
-  stub_home_dir_with { fake_home_dir }
+    let(:fake_home_dir) { nil }
+    stub_home_dir_with { fake_home_dir }
 
-  describe "#wrap_errors" do
-    let(:inputs) { {} }
+    describe "#wrap_errors" do
+      let(:inputs) { {} }
 
-    subject do
-      capture_output do
-        stub(context).input { inputs }
-        context.wrap_errors { action.call }
+      subject do
+        capture_output do
+          context.stub(:input) { inputs }
+          context.wrap_errors { action.call }
+        end
       end
-    end
 
-    context "with a CFoundry::Timeout" do
-      let(:action) { proc { raise CFoundry::Timeout.new(123, "fizzbuzz") } }
+      context "with a CFoundry::Timeout" do
+        let(:action) { proc { raise CFoundry::Timeout.new(123, "fizzbuzz") } }
 
-      it_behaves_like "an error that's obvious to the user",
-        :with_message => "fizzbuzz"
-    end
+        it_behaves_like "an error that's obvious to the user", :with_message => "fizzbuzz"
+      end
 
-    context "with a UserError" do
-      let(:action) { proc { context.fail "foo bar" } }
+      context "with a UserError" do
+        let(:action) { proc { context.fail "foo bar" } }
 
-      it_behaves_like "an error that's obvious to the user",
-        :with_message => "foo bar"
+        it_behaves_like "an error that's obvious to the user",
+          :with_message => "foo bar"
 
-      it "saves it in the crashlog" do
-        mock(context).log_error(anything)
-        subject
+        it "saves it in the crashlog" do
+          context.should_receive(:log_error)
+          subject
+        end
       end
-    end
-
-    context "with a UserFriendlyError" do
-      let(:action) { proc { raise CF::UserFriendlyError.new("user friendly") } }
-
-      it_behaves_like "an error that's obvious to the user",
-        :with_message => "user friendly"
-    end
 
-    context "with a SystemExit" do
-      let(:action) { proc { exit 1 } }
+      context "with a UserFriendlyError" do
+        let(:action) { proc { raise CF::UserFriendlyError.new("user friendly") } }
 
-      it_behaves_like "an error that gets passed through",
-        :with_exception => SystemExit
-    end
+        it_behaves_like "an error that's obvious to the user",
+          :with_message => "user friendly"
+      end
 
-    context "with a Mothership::Error" do
-      let(:action) { proc { raise Mothership::Error } }
+      context "with a SystemExit" do
+        let(:action) { proc { exit 1 } }
 
-      it_behaves_like "an error that gets passed through",
-        :with_exception => Mothership::Error
-    end
+        it_behaves_like "an error that gets passed through",
+          :with_exception => SystemExit
+      end
 
-    context "with an Interrupt" do
-      let(:action) { proc { raise Interrupt } }
+      context "with a Mothership::Error" do
+        let(:action) { proc { raise Mothership::Error } }
 
-      it "sets the exit code to 130" do
-        mock(context).exit_status(130)
-        subject
+        it_behaves_like "an error that gets passed through",
+          :with_exception => Mothership::Error
       end
-    end
 
-    context "when CC can't decode the auth token" do
-      let(:action) { proc { raise CFoundry::InvalidAuthToken.new("foo bar") } }
-      let(:asked) { false }
+      context "with an Interrupt" do
+        let(:action) { proc { raise Interrupt } }
 
-      before do
-        $cf_asked_auth = asked
+        it "sets the exit code to 130" do
+          context.should_receive(:exit_status).with(130)
+          subject
+        end
       end
 
-      it "tells the user they are not authenticated" do
-        subject
-        expect(stdout.string).to include "Invalid authentication token. Try logging in again with 'cf login'. If problems continue, please contact your Cloud Operator."
-      end
+      context "when CC can't decode the auth token" do
+        let(:action) { proc { raise CFoundry::InvalidAuthToken.new("foo bar") } }
+        let(:asked) { false }
 
-      it "exits without attempting to login again" do
-        dont_allow(context).invoke(:login)
-        subject
-      end
-    end
+        before do
+          $cf_asked_auth = asked
+        end
 
-    context "with a CFoundry authentication error" do
-      let(:action) { proc { raise CFoundry::Forbidden.new("foo bar") } }
-      let(:asked) { false }
+        it "tells the user they are not authenticated" do
+          subject
+          expect(stdout.string).to include "Invalid authentication token. Try logging in again with 'cf login'. If problems continue, please contact your Cloud Operator."
+        end
 
-      before do
-        $cf_asked_auth = asked
+        it "exits without attempting to login again" do
+          context.should_not_receive(:invoke)
+          subject
+        end
       end
 
-      it "tells the user they are not authenticated" do
-        stub(context).invoke(:login)
-        subject
-        expect(stdout.string).to include "Not authenticated! Try logging in:"
-        expect($cf_asked_auth).to be_true
-      end
+      context "with a CFoundry authentication error" do
+        let(:action) { proc { raise CFoundry::Forbidden.new("foo bar") } }
+        let(:asked) { false }
 
-      it "asks the user to log in" do
-        mock(context).invoke(:login)
-        subject
-      end
+        before do
+          $cf_asked_auth = asked
+        end
 
-      context "and after logging in they got another authentication error" do
-        let(:asked) { true }
+        it "tells the user they are not authenticated" do
+          context.stub(:invoke)
+          subject
+          expect(stdout.string).to include "Not authenticated! Try logging in:"
+          expect($cf_asked_auth).to be_true
+        end
 
-        it "does not ask them to log in" do
-          dont_allow(context).invoke(:login)
+        it "asks the user to log in" do
+          context.should_receive(:invoke).with(:login)
           subject
         end
 
-        it_behaves_like "an error that's obvious to the user",
-          :with_message => "Denied: foo bar"
-      end
-    end
+        context "and after logging in they got another authentication error" do
+          let(:asked) { true }
 
-    context "with an arbitrary exception" do
-      let(:action) { proc { raise "foo bar" } }
+          it "does not ask them to log in" do
+            context.should_not_receive(:invoke)
+            subject
+          end
 
-      it "logs the error" do
-        mock(context).log_error(anything)
-        subject
+          it_behaves_like "an error that's obvious to the user",
+            :with_message => "Denied: foo bar"
+        end
       end
 
-      it "prints the message" do
-        subject
-        expect(stderr.string).to include "RuntimeError: foo bar"
-      end
+      context "with an arbitrary exception" do
+        let(:action) { proc { raise "foo bar" } }
 
-      it "sets the exit code to 1" do
-        mock(context).exit_status(1)
-        subject
-      end
+        it "logs the error" do
+          context.should_receive(:log_error).with(anything)
+          subject
+        end
 
-      it "tells the user to check ~/.cf/crash" do
-        subject
-        expect(stderr.string).to include CF::CRASH_FILE
-      end
+        it "prints the message" do
+          subject
+          expect(stderr.string).to include "RuntimeError: foo bar"
+        end
 
-      context "when we are debugging" do
-        let(:inputs) { {:debug => true} }
+        it "sets the exit code to 1" do
+          context.should_receive(:exit_status).with(1)
+          subject
+        end
 
-        it_behaves_like "an error that gets passed through",
-          :with_exception => RuntimeError
-      end
-    end
-  end
+        it "tells the user to check ~/.cf/crash" do
+          subject
+          expect(stderr.string).to include CF::CRASH_FILE
+        end
 
-  describe '#execute' do
-    let(:inputs) { {} }
-    let(:client) { fake_client }
+        context "when we are debugging" do
+          let(:inputs) { {:debug => true} }
 
-    before do
-      any_instance_of(CF::CLI) do |cli|
-        stub(cli).client { client }
+          it_behaves_like "an error that gets passed through",
+            :with_exception => RuntimeError
+        end
       end
     end
 
-    subject do
-      capture_output do
-        stub(context).input { inputs }
-        context.execute(command, [])
-      end
-    end
+    describe "#execute" do
+      let(:inputs) { {} }
+      let(:client) { fake_client }
 
-    describe "token refreshing" do
-      let(:context) { TokenRefreshDummy.new }
-      let(:command) { Mothership.commands[:refresh_token] }
-      let(:auth_token) { CFoundry::AuthToken.new("old-header") }
-      let(:new_auth_token) { CFoundry::AuthToken.new("new-header") }
+      before do
+        stub_client
+      end
 
-      class TokenRefreshDummy < CF::CLI
-        class << self
-          attr_accessor :new_token
+      subject do
+        capture_output do
+          context.stub(:input) { inputs }
+          context.execute(command, [])
         end
+      end
 
-        def precondition;
-        end
+      describe "token refreshing" do
+        let(:context) { TokenRefreshDummy.new }
+        let(:command) { Mothership.commands[:refresh_token] }
+        let(:auth_token) { CFoundry::AuthToken.new("old-header") }
+        let(:new_auth_token) { CFoundry::AuthToken.new("new-header") }
 
-        desc "XXX"
-        def refresh_token
-          if client
-            client.token = self.class.new_token
+        class TokenRefreshDummy < CF::CLI
+          class << self
+            attr_accessor :new_token
           end
-        end
-      end
 
-      context "when there is a target" do
-        before do
-          TokenRefreshDummy.new_token = nil
-          client.token = auth_token
+          def precondition;
+          end
+
+          desc "XXX"
+
+          def refresh_token
+            if client
+              client.token = self.class.new_token
+            end
+          end
         end
 
-        context "when the token refreshes" do
-          it "saves to the target file" do
-            any_instance_of(TokenRefreshDummy) do |trd|
-              trd.new_token = new_auth_token
+        context "when there is a target" do
+          before do
+            TokenRefreshDummy.new_token = nil
+            client.token = auth_token
+          end
 
-              stub(trd).target_info { {} }
-              mock(trd).save_target_info(anything) do |info|
+          context "when the token refreshes" do
+            it "saves to the target file" do
+              TokenRefreshDummy.any_instance.stub(:target_info) { {} }
+              TokenRefreshDummy.any_instance.stub(:save_target_info).with(anything) do |info|
                 expect(info[:token]).to eq new_auth_token.auth_header
               end
-            end
 
-            subject
+              subject
+            end
           end
-        end
 
-        context "but there is no token initially" do
-          let(:auth_token) { nil }
+          context "but there is no token initially" do
+            let(:auth_token) { nil }
 
-          it "doesn't save the new token because something else probably did" do
-            dont_allow(context).save_target_info(anything)
-            subject
+            it "doesn't save the new token because something else probably did" do
+              context.should_not_receive(:save_target_info)
+              subject
+            end
           end
-        end
 
-        context "and the token becomes nil" do
-          let(:new_auth_token) { nil }
+          context "and the token becomes nil" do
+            let(:new_auth_token) { nil }
 
-          it "doesn't save the nil token" do
-            dont_allow(context).save_target_info(anything)
-            subject
+            it "doesn't save the nil token" do
+              context.should_not_receive(:save_target_info)
+              subject
+            end
           end
         end
-      end
 
-      context "when there is no target" do
-        let(:client) { nil }
+        context "when there is no target" do
+          let(:client) { nil }
 
-        it "doesn't try to compare the tokens" do
-          expect { subject }.to_not raise_error
+          it "doesn't try to compare the tokens" do
+            expect { subject }.to_not raise_error
+          end
         end
       end
     end
-  end
-
-  describe '#log_error' do
-    subject do
-      context.log_error(exception)
-      File.read(File.expand_path(CF::CRASH_FILE))
-    end
 
-    context 'when the exception is a normal error' do
-      let(:exception) do
-        error = StandardError.new("gemfiles are kinda hard")
-        error.set_backtrace(["fo/gems/bar", "baz quick"])
-        error
+    describe "#log_error" do
+      subject do
+        context.log_error(exception)
+        File.read(File.expand_path(CF::CRASH_FILE))
       end
 
-      it { should include "Time of crash:" }
-      it { should include "gemfiles are kinda hard" }
-      it { should include "bar" }
-      it { should_not include "fo/gems/bar" }
-      it { should include "baz quick" }
-    end
+      context "when the exception is a normal error" do
+        let(:exception) do
+          error = StandardError.new("gemfiles are kinda hard")
+          error.set_backtrace(["fo/gems/bar", "baz quick"])
+          error
+        end
 
-    context 'when the exception is an APIError' do
-      let(:request) { {:method => "GET", :url => "http://api.cloudfoundry.com/foo", :headers => {}, :body => nil} }
-      let(:response) { {:status => 404, :body => "bar", :headers => {}} }
-      let(:exception) do
-        error = CFoundry::APIError.new(nil, nil, request, response)
-        error.set_backtrace(["fo/gems/bar", "baz quick"])
-        error
+        it { should include "Time of crash:" }
+        it { should include "gemfiles are kinda hard" }
+        it { should include "bar" }
+        it { should_not include "fo/gems/bar" }
+        it { should include "baz quick" }
       end
 
-      before do
-        stub(response).body { "Response Body" }
-      end
+      context "when the exception is an APIError" do
+        let(:request) { {:method => "GET", :url => "http://api.cloudfoundry.com/foo", :headers => {}, :body => nil} }
+        let(:response) { {:status => 404, :body => "bar", :headers => {}} }
+        let(:exception) do
+          error = CFoundry::APIError.new(nil, nil, request, response)
+          error.set_backtrace(["fo/gems/bar", "baz quick"])
+          error
+        end
+
+        before do
+          response.stub(:body) { "Response Body" }
+        end
 
-      it { should include "REQUEST: " }
-      it { should include "RESPONSE: " }
+        it { should include "REQUEST: " }
+        it { should include "RESPONSE: " }
+      end
     end
-  end
 
-  describe "#client_target" do
-    subject { context.client_target }
+    describe "#client_target" do
+      subject { context.client_target }
 
-    context "when a ~/.cf/target exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+      context "when a ~/.cf/target exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
-      it "returns the target in that file" do
-        expect(subject).to eq "https://api.some-domain.com"
+        it "returns the target in that file" do
+          expect(subject).to eq "https://api.some-domain.com"
+        end
       end
-    end
 
-    context "when no target file exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+      context "when no target file exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
 
-      it "returns nil" do
-        expect(subject).to eq nil
+        it "returns nil" do
+          expect(subject).to eq nil
+        end
       end
     end
-  end
 
-  describe "#targets_info" do
-    subject { context.targets_info }
+    describe "#targets_info" do
+      subject { context.targets_info }
 
-    context "when a ~/.cf/tokens.yml exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+      context "when a ~/.cf/tokens.yml exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
-      it "returns the file's contents as a hash" do
-        expect(subject).to eq({
-          "https://api.some-domain.com" => {
-            :token => "bearer some-token",
-            :version => 2
-          }
-        })
+        it "returns the file's contents as a hash" do
+          expect(subject).to eq({
+            "https://api.some-domain.com" => {
+              :token => "bearer some-token",
+              :version => 2
+            }
+          })
+        end
       end
-    end
 
-    context "when no token file exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+      context "when no token file exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
 
-      it "returns an empty hash" do
-        expect(subject).to eq({})
+        it "returns an empty hash" do
+          expect(subject).to eq({})
+        end
       end
     end
-  end
 
-  describe "#target_info" do
-    subject { CF::CLI.new.target_info("https://api.some-domain.com") }
+    describe "#target_info" do
+      subject { CF::CLI.new.target_info("https://api.some-domain.com") }
 
-    context "when a ~/.cf/tokens.yml exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+      context "when a ~/.cf/tokens.yml exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
-      it "returns the info for the given url" do
-        expect(subject).to eq({
-          :token => "bearer some-token",
-          :version => 2
-        })
+        it "returns the info for the given url" do
+          expect(subject).to eq({
+            :token => "bearer some-token",
+            :version => 2
+          })
+        end
       end
-    end
 
-    context "when no token file exists" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+      context "when no token file exists" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
 
-      it "returns an empty hash" do
-        expect(subject).to eq({})
+        it "returns an empty hash" do
+          expect(subject).to eq({})
+        end
       end
     end
-  end
 
-  describe "methods that update the token info" do
-    before do
-      stub(context).targets_info do
-        {
-          "https://api.some-domain.com" => {:token => "bearer token1"},
-          "https://api.some-other-domain.com" => {:token => "bearer token2"}
-        }
+    describe "methods that update the token info" do
+      before do
+        context.stub(:targets_info) do
+          {
+            "https://api.some-domain.com" => {:token => "bearer token1"},
+            "https://api.some-other-domain.com" => {:token => "bearer token2"}
+          }
+        end
       end
-    end
 
-    describe "#save_target_info" do
-      it "adds the given target info, and writes the result to ~/.cf/tokens.yml" do
-        context.save_target_info({:token => "bearer token3"}, "https://api.some-domain.com")
-        YAML.load_file(File.expand_path("~/.cf/tokens.yml")).should == {
-          "https://api.some-domain.com" => {:token => "bearer token3"},
-          "https://api.some-other-domain.com" => {:token => "bearer token2"}
-        }
+      describe "#save_target_info" do
+        it "adds the given target info, and writes the result to ~/.cf/tokens.yml" do
+          context.save_target_info({:token => "bearer token3"}, "https://api.some-domain.com")
+          YAML.load_file(File.expand_path("~/.cf/tokens.yml")).should == {
+            "https://api.some-domain.com" => {:token => "bearer token3"},
+            "https://api.some-other-domain.com" => {:token => "bearer token2"}
+          }
+        end
       end
-    end
 
-    describe "#remove_target_info" do
-      it "removes the given target, and writes the result to ~/.cf/tokens.yml" do
-        context.remove_target_info("https://api.some-domain.com")
-        YAML.load_file(File.expand_path("~/.cf/tokens.yml")).should == {
-          "https://api.some-other-domain.com" => {:token => "bearer token2"}
-        }
+      describe "#remove_target_info" do
+        it "removes the given target, and writes the result to ~/.cf/tokens.yml" do
+          context.remove_target_info("https://api.some-domain.com")
+          YAML.load_file(File.expand_path("~/.cf/tokens.yml")).should == {
+            "https://api.some-other-domain.com" => {:token => "bearer token2"}
+          }
+        end
       end
     end
-  end
 
-  describe "#client" do
-    let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+    describe "#client" do
+      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
-    before { stub(context).input { {} } }
+      before { context.stub(:input).and_return({}) }
 
-    describe "the client's token" do
-      it "constructs an AuthToken object with the data from the tokens.yml file" do
-        expect(context.client.token).to be_a(CFoundry::AuthToken)
-        expect(context.client.token.auth_header).to eq("bearer some-token")
-      end
+      describe "the client's token" do
+        it "constructs an AuthToken object with the data from the tokens.yml file" do
+          expect(context.client.token).to be_a(CFoundry::AuthToken)
+          expect(context.client.token.auth_header).to eq("bearer some-token")
+        end
 
-      it "does not assign an AuthToken on the client if there is no token stored" do
-        mock(context).target_info("some-fake-target") { {:version => 2} }
-        expect(context.client("some-fake-target").token).to be_nil
+        it "does not assign an AuthToken on the client if there is no token stored" do
+          context.should_receive(:target_info).with("some-fake-target") { {:version => 2} }
+          expect(context.client("some-fake-target").token).to be_nil
+        end
       end
-    end
 
-    describe "the client's version" do
-      it "uses the version stored in the yml file" do
-        expect(context.client.version).to eq(2)
+      describe "the client's version" do
+        it "uses the version stored in the yml file" do
+          expect(context.client.version).to eq(2)
+        end
       end
-    end
 
-    context "when there is no target" do
-      let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+      context "when there is no target" do
+        let(:fake_home_dir) { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
 
-      it "returns nil" do
-        expect(context.client).to eq(nil)
+        it "returns nil" do
+          expect(context.client).to eq(nil)
+        end
       end
-    end
 
-    context "with a cloud controller" do
-      before do
-        stub(context).target_info { {:version => 2} }
-      end
+      context "with a cloud controller" do
+        before do
+          context.stub(:target_info) { {:version => 2} }
+        end
 
-      it "connects using the v2 api" do
-        expect(context.client).to be_a(CFoundry::V2::Client)
-      end
+        it "connects using the v2 api" do
+          expect(context.client).to be_a(CFoundry::V2::Client)
+        end
 
-      %w{https_proxy HTTPS_PROXY http_proxy HTTP_PROXY}.each do |variable|
-        proxy_name = variable.downcase.to_sym
+        %w{https_proxy HTTPS_PROXY http_proxy HTTP_PROXY}.each do |variable|
+          proxy_name = variable.downcase.to_sym
 
-        context "when ENV['#{variable}'] is set" do
-          before { ENV[variable] = "http://lower.example.com:80" }
-          after  { ENV.delete(variable) }
+          context "when ENV['#{variable}'] is set" do
+            before { ENV[variable] = "http://lower.example.com:80" }
+            after { ENV.delete(variable) }
 
-          it "uses the #{proxy_name} proxy URI on the environment variable" do
-            expect(context.client.send(proxy_name)).to eq('http://lower.example.com:80')
+            it "uses the #{proxy_name} proxy URI on the environment variable" do
+              expect(context.client.send(proxy_name)).to eq("http://lower.example.com:80")
+            end
           end
         end
-      end
 
-      context 'when both input and environment variable are provided' do
-        before do
-          ENV['HTTPS_PROXY'] = "http://should.be.overwritten.example.com:80"
-          stub(context).input { {:https_proxy => 'http://arg.example.com:80'} }
-        end
+        context "when both input and environment variable are provided" do
+          before do
+            ENV["HTTPS_PROXY"] = "http://should.be.overwritten.example.com:80"
+            context.stub(:input) { {:https_proxy => "http://arg.example.com:80"} }
+          end
 
-        after { ENV.delete('HTTPS_PROXY') }
+          after { ENV.delete("HTTPS_PROXY") }
 
-        it "uses the provided https proxy URI" do
-          expect(context.client.https_proxy).to eq('http://arg.example.com:80')
+          it "uses the provided https proxy URI" do
+            expect(context.client.https_proxy).to eq("http://arg.example.com:80")
+          end
         end
       end
     end
   end
 end
-