cf 1.1.3.rc1 → 1.1.4

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

@@ -1,121 +1,118 @@
 require "spec_helper"
-require "webmock/rspec"
 
-describe CF::Start::Target do
-  before do
-    stub_client_and_precondition
-  end
-
-  let(:client) { fake_client :apps => [app] }
-  let(:app) { fake :app }
+module CF
+  module Start
+    describe Target do
+      before do
+        stub_client_and_precondition
+      end
 
-  describe "metadata" do
-    let(:command) { Mothership.commands[:target] }
+      let(:client) { fake_client :apps => [app] }
+      let(:app) { fake :app }
 
-    describe "command" do
-      subject { command }
-      its(:description) { should eq "Set or display the target cloud, organization, and space" }
-      specify { expect(Mothership::Help.group(:start)).to include(subject) }
-    end
+      describe "metadata" do
+        let(:command) { Mothership.commands[:target] }
 
-    include_examples "inputs must have descriptions"
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Set or display the target cloud, organization, and space" }
+          specify { expect(Mothership::Help.group(:start)).to include(subject) }
+        end
 
-    describe "flags" do
-      subject { command.flags }
+        include_examples "inputs must have descriptions"
 
-      its(["-o"]) { should eq :organization }
-      its(["--org"]) { should eq :organization }
-      its(["-s"]) { should eq :space }
-    end
+        describe "flags" do
+          subject { command.flags }
 
-    describe "arguments" do
-      subject(:arguments) { command.arguments }
-      it "have the correct commands" do
-        expect(arguments).to eq [{:type => :optional, :value => nil, :name => :url}]
-      end
-    end
-  end
-
-  describe "running the command" do
-    stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
-
-    context "when the user is authenticated and has an organization" do
-      let(:user) { stub! }
-      let(:organization) { fake(:organization, :name => "My Org", :guid => "organization-id-1", :users => [user], :spaces => [space]) }
-      let(:space) { fake(:space, :name => "Staging", :guid => "space-id-2", :developers => [user]) }
-      let(:client) { fake_client :organizations => [organization], :token => CFoundry::AuthToken.new("bearer some-access-token") }
+          its(["-o"]) { should eq :organization }
+          its(["--org"]) { should eq :organization }
+          its(["-s"]) { should eq :space }
+        end
 
-      before do
-        stub(client).current_user { user }
-        stub(client).organization { organization }
-        stub(client).current_organization { organization }
-        any_instance_of(described_class) do |instance|
-          stub(instance).client { client }
+        describe "arguments" do
+          subject(:arguments) { command.arguments }
+          it "have the correct commands" do
+            expect(arguments).to eq [{:type => :optional, :value => nil, :name => :url}]
+          end
         end
       end
 
-      describe "switching the target" do
-        let(:target) { "some-valid-target.com" }
-        subject { cf ["target", target] }
+      describe "running the command" do
+        stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
-        context "when the target is not valid" do
-          before { WebMock.stub_request(:get, "http://#{target}/info").to_return(:body => "{}") }
+        context "when the user is authenticated and has an organization" do
+          let(:user) { fake(:user) }
+          let(:organization) { fake(:organization, :name => "My Org", :guid => "organization-id-1", :users => [user], :spaces => [space]) }
+          let(:space) { fake(:space, :name => "Staging", :guid => "space-id-2", :developers => [user]) }
+          let(:client) { fake_client :organizations => [organization], :token => CFoundry::AuthToken.new("bearer some-access-token") }
 
-          it "should still be able to switch to a valid target after that" do
-            subject
+          before do
+            client.stub(:current_user) { user }
+            client.stub(:organization) { organization }
+            client.stub(:current_organization) { organization }
+            described_class.any_instance.stub(:client) { client }
           end
-        end
 
-        context "when the target is valid but the connection is refused" do
-          it "shows a pretty error message" do
-            any_instance_of(CFoundry::V2::Client) do |cli|
-              stub(cli).info { raise CFoundry::TargetRefused, "foo" }
+          describe "switching the target" do
+            let(:target) { "some-valid-target.com" }
+            subject { cf ["target", target] }
+
+            context "when the target is not valid" do
+              before { WebMock.stub_request(:get, "http://#{target}/info").to_return(:body => "{}") }
+
+              it "should still be able to switch to a valid target after that" do
+                subject
+              end
             end
 
-            subject
-            expect(error_output).to say("Target refused connection.")
-          end
-        end
+            context "when the target is valid but the connection is refused" do
+              it "shows a pretty error message" do
+                CFoundry::V2::Client.any_instance.stub(:info) { raise CFoundry::TargetRefused, "foo" }
 
-        context "when the uri is malformed" do
-          it "shows a pretty error message" do
-            any_instance_of(CFoundry::V2::Client) do |cli|
-              stub(cli).info { raise CFoundry::InvalidTarget.new(target) }
+                subject
+                expect(error_output).to say("Target refused connection.")
+              end
             end
 
-            subject
-            expect(error_output).to say("Invalid target URI.")
+            context "when the uri is malformed" do
+              it "shows a pretty error message" do
+                CFoundry::V2::Client.any_instance.stub(:info) { raise CFoundry::InvalidTarget.new(target) }
+
+                subject
+                expect(error_output).to say("Invalid target URI.")
+              end
+            end
           end
-        end
-      end
 
-      describe "switching the space" do
-        def run_command
-          cf %W[target -s #{space.name}]
-        end
+          describe "switching the space" do
+            def run_command
+              cf %W[target -s #{space.name}]
+            end
 
-        it "calls use a PopulateTarget to ensure that an organization and space is set" do
-          mock(CF::Populators::Target).new(is_a(Mothership::Inputs)) { mock!.populate_and_save! }
-          run_command
-        end
+            it "calls use a PopulateTarget to ensure that an organization and space is set" do
+              CF::Populators::Target.should_receive(:new) { double(:target, :populate_and_save! => true) }
+              run_command
+            end
 
-        it "prints out the space from the updated client" do
-          any_instance_of(CF::Populators::Target, :populate_and_save! => true)
-          stub(client).current_space { space }
+            it "prints out the space from the updated client" do
+              CF::Populators::Target.any_instance.stub(:populate_and_save!) { true }
+              client.stub(:current_space) { space }
 
-          run_command
-          expect(output).to say("space: #{space.name}")
+              run_command
+              expect(output).to say("space: #{space.name}")
+            end
+          end
         end
-      end
-    end
 
-    context "when client is nil" do
-      let(:client) { nil }
-      subject { cf ["target"] }
+        context "when client is nil" do
+          let(:client) { nil }
+          subject { cf ["target"] }
 
-      it 'prints an error' do
-        subject
-        expect(error_output).to say("No target has been specified.")
+          it 'prints an error' do
+            subject
+            expect(error_output).to say("No target has been specified.")
+          end
+        end
       end
     end
   end

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

@@ -1,99 +1,98 @@
-require 'spec_helper'
-
-describe CF::User::Create do
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:create_user] }
-
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Create a user" }
-      it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
-    end
-
-    include_examples 'inputs must have descriptions'
-
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'has the correct argument order' do
-        should eq([
-          { :type => :optional, :value => nil, :name => :email }
-        ])
-      end
-    end
-  end
-
-  describe "running the command" do
-    let(:client) { fake_client }
-    let(:org) { fake(:organization) }
-    let(:user) { fake(:user) }
-
-    before do
-      any_instance_of(described_class) { |cli| stub(cli).client { client } }
-      stub(client).register
-    end
-
-    subject { cf %W[create-user --#{bool_flag(:force)}] }
-
-    context "when the user is not logged in" do
-      let(:force) { true }
-
-      before do
-        stub(client).logged_in? { false }
-      end
-
-      it "tells the user to log in" do
-        subject
-        expect(stderr.string).to include("Please log in")
-      end
-    end
-
-    context "when the user is logged in" do
-      let(:force) { false }
-      let(:confirmation) { "password1" }
-
-      before do
-        stub(client).logged_in? { true }
-        stub_ask("Email") { "some-angry-dude@example.com" }
-        stub_ask("Password", anything) { "password1" }
-        stub_ask("Verify Password", anything) { confirmation }
-        stub(CF::Populators::Organization).new(instance_of(Mothership::Inputs)) { stub!.populate_and_save! { org } }
+require "spec_helper"
+
+module CF
+  module User
+    describe Create do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:create_user] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Create a user" }
+          it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+        end
 
-        stub(client).register("some-angry-dude@example.com", "password1") { user }
-        stub(user).update!
-      end
+        include_examples "inputs must have descriptions"
 
-      it "ensures that an org is present" do
-        mock(CF::Populators::Organization).new(instance_of(Mothership::Inputs)) { stub!.populate_and_save! { org } }
-        subject
+        describe "arguments" do
+          subject { command.arguments }
+          it "has the correct argument order" do
+            should eq([
+              {:type => :optional, :value => nil, :name => :email}
+            ])
+          end
+        end
       end
 
-      context "when the password does not match its confirmation" do
-        let(:confirmation) { "wrong" }
+      describe "running the command" do
+        let(:client) { fake_client }
+        let(:org) { fake(:organization) }
+        let(:user) { fake(:user) }
 
-        it "displays an error message" do
-          subject
-          expect(stderr.string).to include("Passwords don't match")
+        before do
+          stub_client
+          client.stub(:register)
         end
-      end
 
-      context "when the password matches its confirmation" do
-        it "creates a user" do
-          mock(client).register("some-angry-dude@example.com", "password1") { user }
-          stub(user).update!
-          subject
-        end
+        subject { cf %W[create-user --#{bool_flag(:force)}] }
 
-        it "adds the user to the current org" do
-          stub(client).register(anything, anything) { user }
-          mock(user).update!
+        context "when the user is not logged in" do
+          let(:force) { true }
 
-          subject
+          before do
+            client.stub(:logged_in?) { false }
+          end
 
-          user.organizations.should == [org]
-          user.managed_organizations.should == [org]
-          user.audited_organizations.should == [org]
+          it "tells the user to log in" do
+            subject
+            expect(stderr.string).to include("Please log in")
+          end
         end
 
+        context "when the user is logged in" do
+          let(:force) { false }
+          let(:confirmation) { "password1" }
+
+          before do
+            client.stub(:logged_in?) { true }
+            stub_ask("Email") { "some-angry-dude@example.com" }
+            stub_ask("Password", anything) { "password1" }
+            stub_ask("Verify Password", anything) { confirmation }
+
+            CF::Populators::Organization.stub(:new) { stub(:organization, :populate_and_save! => org) }
+            client.stub(:register).with("some-angry-dude@example.com", "password1") { user }
+            user.stub(:update!)
+          end
+
+          context "when the password does not match its confirmation" do
+            let(:confirmation) { "wrong" }
+
+            it "displays an error message" do
+              subject
+              expect(stderr.string).to include("Passwords don't match")
+            end
+          end
+
+          context "when the password matches its confirmation" do
+            it "creates a user" do
+              client.should_receive(:register).with("some-angry-dude@example.com", "password1") { user }
+              user.stub(:update!)
+              subject
+            end
+
+            it "adds the user to the current org" do
+              client.stub(:register).and_return(user)
+              user.should_receive(:update!)
+
+              subject
+
+              user.organizations.should == [org]
+              user.managed_organizations.should == [org]
+              user.audited_organizations.should == [org]
+            end
+
+          end
+        end
       end
     end
   end

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

@@ -1,94 +1,95 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe CF::User::Passwd do
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:passwd] }
+module CF
+  module User
+    describe Passwd do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:passwd] }
 
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Update the current user's password" }
-      it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
-    end
-
-    include_examples 'inputs must have descriptions'
-  end
-
-  describe '#passwd' do
-    let(:client) { fake_client }
-    let(:old_password) { "old" }
-    let(:new_password) { "password" }
-    let(:verify_password) { new_password }
-    let(:score) { :strong }
-    let(:guid) { random_string("my-object-guid") }
-    let(:user_model) { fake_model { attribute :password, :object } }
-    let(:user_object) { user_model.new(guid, client) }
-    let(:user) { user_object.fake(:password => 'foo') }
-
-    before do
-      any_instance_of described_class do |cli|
-        stub(cli).client { client }
-        stub(cli).precondition { nil }
-      end
-      stub(client).logged_in? { true }
-      stub(client).current_user { user }
-      stub(client).register
-      stub(client).base.stub!.password_score(new_password) { score }
-    end
-
-    subject { cf %W[passwd --password #{old_password} --new-password #{new_password} --verify #{verify_password} --no-force --debug] }
-
-    context 'when the passwords dont match' do
-      let(:verify_password) { "other_password" }
-
-      it { should eq 1 }
-
-      it 'fails' do
-        subject
-        expect(stderr.string).to include "Passwords do not match."
-      end
-
-      it "doesn't print out the score" do
-        subject
-        expect(stdout.string).not_to include "strength"
-      end
-
-      it "doesn't log in or register" do
-        dont_allow(user).change_password!
-        subject
-      end
-    end
-
-    context 'when the password is good or strong' do
-      before do
-        stub(user).change_password!
-      end
-
-      it { should eq 0 }
-
-      it 'prints out the password score' do
-        subject
-        expect(stdout.string).to include "Your password strength is: strong"
-      end
-
-      it 'changes the password' do
-        mock(user).change_password!(new_password, old_password)
-        subject
-      end
-    end
-
-    context 'when the password is weak' do
-      let(:score) { :weak }
-
-      it { should eq 1 }
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Update the current user's password" }
+          it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+        end
 
-      it 'prints out the password score' do
-        subject
-        expect(stderr.string).to include "Your password strength is: weak"
+        include_examples "inputs must have descriptions"
       end
 
-      it "doesn't change the password" do
-        dont_allow(user).change_password!
-        subject
+      describe "#passwd" do
+        let(:client) { fake_client }
+        let(:old_password) { "old" }
+        let(:new_password) { "password" }
+        let(:verify_password) { new_password }
+        let(:score) { :strong }
+        let(:guid) { random_string("my-object-guid") }
+        let(:user_model) { fake_model { attribute :password, :object } }
+        let(:user_object) { user_model.new(guid, client) }
+        let(:user) { user_object.fake(:password => "foo") }
+
+        before do
+          stub_client_and_precondition
+          client.stub(:logged_in?) { true }
+          client.stub(:current_user) { user }
+          client.stub(:register)
+          client.base.stub(:password_score).with(new_password).and_return(score)
+        end
+
+        subject { cf %W[passwd --password #{old_password} --new-password #{new_password} --verify #{verify_password} --no-force --debug] }
+
+        context "when the passwords dont match" do
+          let(:verify_password) { "other_password" }
+
+          it { should eq 1 }
+
+          it "fails" do
+            subject
+            expect(stderr.string).to include "Passwords do not match."
+          end
+
+          it "doesn't print out the score" do
+            subject
+            expect(stdout.string).not_to include "strength"
+          end
+
+          it "doesn't log in or register" do
+            user.should_not_receive(:change_password!)
+            subject
+          end
+        end
+
+        context "when the password is good or strong" do
+          before do
+            user.stub(:change_password!)
+          end
+
+          it { should eq 0 }
+
+          it "prints out the password score" do
+            subject
+            expect(stdout.string).to include "Your password strength is: strong"
+          end
+
+          it "changes the password" do
+            user.should_receive(:change_password!).with(new_password, old_password)
+            subject
+          end
+        end
+
+        context "when the password is weak" do
+          let(:score) { :weak }
+
+          it { should eq 1 }
+
+          it "prints out the password score" do
+            subject
+            expect(stderr.string).to include "Your password strength is: weak"
+          end
+
+          it "doesn't change the password" do
+            user.should_not_receive(:change_password!)
+            subject
+          end
+        end
       end
     end
   end