cf 1.1.3.rc1 → 1.1.4

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

@@ -1,92 +1,93 @@
-require 'spec_helper'
-require "cf/cli/organization/delete"
+require "spec_helper"
 
-describe CF::Organization::Delete do
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:delete_org] }
+module CF
+  module Organization
+    describe Delete do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:delete_org] }
 
-    describe 'command' do
-      subject { command }
-      it { expect(Mothership::Help.group(:organizations)).to include(subject) }
-    end
-
-    include_examples 'inputs must have descriptions'
-  end
-
-  describe "running the command" do
-    let(:organization) { fake(:organization, :name => "MyOrg") }
-    let(:organizations) { [organization] }
-
-    let(:client) { fake_client(:current_organization => organization, :organizations => organizations) }
-
-    subject { capture_output { cf %W[delete-org MyOrg --quiet --force] } }
-
-    before do
-      any_instance_of described_class do |cli|
-        stub(cli).client { client }
-
-        stub(cli).check_logged_in
-        stub(cli).check_target
-        any_instance_of(CF::Populators::Organization, :populate_and_save! => organization)
-      end
-      stub(organization).delete!
-    end
-
-    context "without the force parameter" do
-      subject { cf %W[delete-org MyOrg --quiet] }
-      it "confirms deletion of the organization and deletes it" do
-        mock(organization).delete!
-        mock_ask("Really delete #{organization.name}?", {:default => false}) { true }
-
-        subject
-      end
-    end
-
-    context "when deleting the last organization" do
-      it "warns the user what they've done" do
-        subject
-        expect(output).to say("There are no longer any organizations.")
-      end
-    end
-
-    context "when deleting the current organization" do
-      let(:organizations) { [organization, fake(:organization)] }
-      it "invalidates the old target / client" do
-        any_instance_of(described_class) { |cli| mock(cli).invalidate_client }
-        subject
-      end
+        describe "command" do
+          subject { command }
+          it { expect(Mothership::Help.group(:organizations)).to include(subject) }
+        end
 
-      it "invokes the target command" do
-        mock_invoke :target
-        subject
+        include_examples "inputs must have descriptions"
       end
-    end
-
-    context "when an org fails to delete" do
-      before do
-        stub(organization).delete! { raise CFoundry::AssociationNotEmpty.new("We don't delete children.", 10006) }
-        subject
-      end
-
-      it "shows the error message" do
-        expect(output).to say "We don't delete children."
-      end
-
-      it "informs the user of how to recursively delete" do
-        expect(output).to say "If you want to delete the organization along with all dependent objects, rerun the command with the '--recursive' flag."
-      end
-
-      it "returns a non-zero exit code" do
-        @status.should_not == 0
-      end
-    end
-
-    context "when deleting with --recursive" do
-      subject { cf %W[delete-org MyOrg --recursive --force] }
 
-      it "sends recursive true in its delete request" do
-        mock(organization).delete!(:recursive => true)
-        subject
+      describe "running the command" do
+        let(:organization) { fake(:organization, :name => "MyOrg") }
+        let(:organizations) { [organization] }
+
+        let(:client) { fake_client(:current_organization => organization, :organizations => organizations) }
+
+        subject { capture_output { cf %W[delete-org MyOrg --quiet --force] } }
+
+        before do
+          described_class.any_instance.stub(:client) { client }
+          described_class.any_instance.stub(:check_logged_in)
+          described_class.any_instance.stub(:check_target)
+          CF::Populators::Organization.any_instance.stub(:populate_and_save!).and_return(organization)
+          organization.stub(:delete!).and_return(true)
+        end
+
+        context "without the force parameter" do
+          subject { cf %W[delete-org MyOrg --quiet] }
+
+          it "confirms deletion of the organization and deletes it" do
+            organization.should_receive(:delete!).with(:recursive => false) { true }
+            mock_ask("Really delete #{organization.name}?", {:default => false}) { true }
+
+            subject
+          end
+        end
+
+        context "when deleting the last organization" do
+          it "warns the user what they've done" do
+            subject
+            expect(output).to say("There are no longer any organizations.")
+          end
+        end
+
+        context "when deleting the current organization" do
+          let(:organizations) { [organization, fake(:organization)] }
+          it "invalidates the old target / client" do
+            described_class.any_instance.should_receive(:invalidate_client)
+            subject
+          end
+
+          it "invokes the target command" do
+            mock_invoke :target
+            subject
+          end
+        end
+
+        context "when an org fails to delete" do
+          before do
+            organization.stub(:delete!) { raise CFoundry::AssociationNotEmpty.new("We don't delete children.", 10006) }
+            subject
+          end
+
+          it "shows the error message" do
+            expect(output).to say "We don't delete children."
+          end
+
+          it "informs the user of how to recursively delete" do
+            expect(output).to say "If you want to delete the organization along with all dependent objects, rerun the command with the '--recursive' flag."
+          end
+
+          it "returns a non-zero exit code" do
+            @status.should_not == 0
+          end
+        end
+
+        context "when deleting with --recursive" do
+          subject { cf %W[delete-org MyOrg --recursive --force] }
+
+          it "sends recursive true in its delete request" do
+            organization.should_receive(:delete!).with(:recursive => true)
+            subject
+          end
+        end
       end
     end
   end

data/spec/cf/cli/organization/orgs_spec.rb

@@ -1,107 +1,104 @@
-require 'spec_helper'
-require 'stringio'
-
-describe CF::Organization::Orgs do
-  let(:global) { { :color => false } }
-  let(:inputs) { {} }
-  let(:given) { {} }
-  let(:output) { StringIO.new }
-
-  let(:client) { fake_client(:organizations => organizations) }
-  let!(:org_1) { fake(:organization, :name => "bb_second", :spaces => fake_list(:space, 2), :domains => [fake(:domain)]) }
-  let!(:org_2) { fake(:organization, :name => "aa_first", :spaces => [fake(:space)], :domains => fake_list(:domain, 3)) }
-  let!(:org_3) { fake(:organization, :name => "cc_last", :spaces => fake_list(:space, 2), :domains => fake_list(:domain, 2)) }
-  let(:organizations) { [org_1, org_2, org_3]}
-
-  before do
-    any_instance_of(CF::CLI) do |cli|
-      stub(cli).client { client }
-      stub(cli).precondition { nil }
-    end
-  end
-
-  subject do
-    capture_output { Mothership.new.invoke(:orgs, inputs, given, global) }
-  end
-
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:orgs] }
-
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "List available organizations" }
-      it { expect(Mothership::Help.group(:organizations)).to include(subject) }
-    end
-
-    include_examples 'inputs must have descriptions'
+require "spec_helper"
+
+module CF
+  module Organization
+    describe Orgs do
+      let(:global) { {:color => false} }
+      let(:inputs) { {} }
+      let(:given) { {} }
+      let(:output) { StringIO.new }
+
+      let(:client) { fake_client(:organizations => organizations) }
+      let!(:org_1) { fake(:organization, :name => "bb_second", :spaces => fake_list(:space, 2), :domains => [fake(:domain)]) }
+      let!(:org_2) { fake(:organization, :name => "aa_first", :spaces => [fake(:space)], :domains => fake_list(:domain, 3)) }
+      let!(:org_3) { fake(:organization, :name => "cc_last", :spaces => fake_list(:space, 2), :domains => fake_list(:domain, 2)) }
+      let(:organizations) { [org_1, org_2, org_3] }
+
+      before do
+        CF::CLI.any_instance.stub(:client) { client }
+        CF::CLI.any_instance.stub(:precondition) { nil }
+      end
 
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'has no arguments' do
-        should be_empty
+      subject do
+        capture_output { Mothership.new.invoke(:orgs, inputs, given, global) }
       end
-    end
-  end
 
-  it 'should have the correct first two lines' do
-    subject
-    stdout.rewind
-    expect(stdout.readline).to match /Getting organizations.*OK/
-    expect(stdout.readline).to eq "\n"
-  end
+      describe "metadata" do
+        let(:command) { Mothership.commands[:orgs] }
 
-  context 'when there are no organizations' do
-    let(:organizations) { [] }
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "List available organizations" }
+          it { expect(Mothership::Help.group(:organizations)).to include(subject) }
+        end
 
-    context 'and the full flag is given' do
-      let(:inputs) { {:full => true} }
+        include_examples "inputs must have descriptions"
 
-      it 'displays yaml-style output with all organization details' do
-        any_instance_of CF::Organization::Orgs do |orgs|
-          dont_allow(orgs).invoke
+        describe "arguments" do
+          subject { command.arguments }
+          it "has no arguments" do
+            should be_empty
+          end
         end
-        subject
       end
-    end
 
-    context 'and the full flag is not given (default is false)' do
-      it 'should show only the progress' do
+      it "should have the correct first two lines" do
         subject
-
         stdout.rewind
         expect(stdout.readline).to match /Getting organizations.*OK/
-        expect(stdout).to be_eof
+        expect(stdout.readline).to eq "\n"
       end
-    end
-  end
 
-  context 'when there are organizations' do
-    context 'and the full flag is given' do
-      let(:inputs) { {:full => true} }
+      context "when there are no organizations" do
+        let(:organizations) { [] }
+
+        context "and the full flag is given" do
+          let(:inputs) { {:full => true} }
 
-      it 'displays yaml-style output with all organization details' do
-        any_instance_of CF::Organization::Orgs do |orgs|
-          mock(orgs).invoke(:org, :organization => org_2, :full => true).ordered
-          mock(orgs).invoke(:org, :organization => org_1, :full => true).ordered
-          mock(orgs).invoke(:org, :organization => org_3, :full => true).ordered
+          it "displays yaml-style output with all organization details" do
+            CF::Organization::Orgs.any_instance.should_not_receive(:invoke)
+            subject
+          end
+        end
+
+        context "and the full flag is not given (default is false)" do
+          it "should show only the progress" do
+            subject
+
+            stdout.rewind
+            expect(stdout.readline).to match /Getting organizations.*OK/
+            expect(stdout).to be_eof
+          end
         end
-        subject
       end
-    end
 
-    context 'and the full flag is not given (default is false)' do
-      it 'displays tabular output with names, spaces and domains' do
-        subject
+      context "when there are organizations" do
+        context "and the full flag is given" do
+          let(:inputs) { {:full => true} }
 
-        stdout.rewind
-        stdout.readline
-        stdout.readline
+          it "displays yaml-style output with all organization details" do
+            CF::Organization::Orgs.any_instance.should_receive(:invoke).with(:org, :organization => org_2, :full => true)
+            CF::Organization::Orgs.any_instance.should_receive(:invoke).with(:org, :organization => org_1, :full => true)
+            CF::Organization::Orgs.any_instance.should_receive(:invoke).with(:org, :organization => org_3, :full => true)
+            subject
+          end
+        end
+
+        context "and the full flag is not given (default is false)" do
+          it "displays tabular output with names, spaces and domains" do
+            subject
+
+            stdout.rewind
+            stdout.readline
+            stdout.readline
 
-        expect(stdout.readline).to match /name\s+spaces\s+domains/
-        organizations.sort_by(&:name).each do |org|
-          expect(stdout.readline).to match /#{org.name}\s+#{name_list(org.spaces)}\s+#{name_list(org.domains)}/
+            expect(stdout.readline).to match /name\s+spaces\s+domains/
+            organizations.sort_by(&:name).each do |org|
+              expect(stdout.readline).to match /#{org.name}\s+#{name_list(org.spaces)}\s+#{name_list(org.domains)}/
+            end
+            expect(stdout).to be_eof
+          end
         end
-        expect(stdout).to be_eof
       end
     end
   end

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

@@ -1,111 +1,112 @@
-require 'spec_helper'
-require "cf/cli/organization/rename"
-
-describe CF::Organization::Rename do
-  let(:global) { { :color => false, :quiet => true } }
-  let(:inputs) { {} }
-  let(:given) { {} }
-  let(:organizations) { fake_list(:organization, 3) }
-  let(:client) { fake_client(:organizations => organizations) }
-  let(:new_name) { "some-new-name" }
-
-  before do
-    any_instance_of(CF::CLI) do |cli|
-      stub(cli).client { client }
-      stub(cli).precondition { nil }
-    end
-  end
+require "spec_helper"
+
+module CF
+  module Organization
+    describe Rename do
+      let(:global) { {:color => false, :quiet => true} }
+      let(:inputs) { {} }
+      let(:given) { {} }
+      let(:organizations) { fake_list(:organization, 3) }
+      let(:client) { fake_client(:organizations => organizations) }
+      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
 
-  subject { Mothership.new.invoke(:rename_org, inputs, given, global) }
+      subject { Mothership.new.invoke(:rename_org, inputs, given, global) }
 
-  describe 'metadata' do
-    let(:command) { Mothership.commands[:rename_org] }
+      describe "metadata" do
+        let(:command) { Mothership.commands[:rename_org] }
 
-    describe 'command' do
-      subject { command }
-      its(:description) { should eq "Rename an organization" }
-      it { expect(Mothership::Help.group(:organizations)).to include(subject) }
-    end
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Rename an organization" }
+          it { expect(Mothership::Help.group(:organizations)).to include(subject) }
+        end
 
-    describe 'inputs' do
-      subject { command.inputs }
+        describe "inputs" do
+          subject { command.inputs }
 
-      it "is not missing any descriptions" do
-        subject.each do |input, attrs|
-          expect(attrs[:description]).to be
-          expect(attrs[:description].strip).to_not be_empty
+          it "is not missing any descriptions" do
+            subject.each do |input, attrs|
+              expect(attrs[:description]).to be
+              expect(attrs[:description].strip).to_not be_empty
+            end
+          end
         end
-      end
-    end
 
-    describe 'arguments' do
-      subject { command.arguments }
-      it 'has the correct argument order' do
-        should eq([
-          { :type => :optional, :value => nil, :name => :organization },
-          { :type => :optional, :value => nil, :name => :name }
-        ])
+        describe "arguments" do
+          subject { command.arguments }
+          it "has the correct argument order" do
+            should eq([
+              {:type => :optional, :value => nil, :name => :organization},
+              {:type => :optional, :value => nil, :name => :name}
+            ])
+          end
+        end
       end
-    end
-  end
 
-  context 'when there are no organizations' do
-    let(:organizations) { [] }
+      context "when there are no organizations" do
+        let(:organizations) { [] }
 
-    context 'and an organization is given' do
-      let(:given) { { :organization => "some-invalid-organization" } }
-      it { expect { subject }.to raise_error(CF::UserError, "Unknown organization 'some-invalid-organization'.") }
-    end
-
-    context 'and an organization is not given' do
-      it { expect { subject }.to raise_error(CF::UserError, "No organizations.") }
-    end
-  end
-
-  context 'when there are organizations' do
-    let(:renamed_organization) { organizations.first }
+        context "and an organization is given" do
+          let(:given) { {:organization => "some-invalid-organization"} }
+          it { expect { subject }.to raise_error(CF::UserError, "Unknown organization 'some-invalid-organization'.") }
+        end
 
-    context 'when the defaults are used' do
-      it 'asks for the organization and new name and renames' do
-        mock_ask("Rename which organization?", anything) { renamed_organization }
-        mock_ask("New name") { new_name }
-        mock(renamed_organization).name=(new_name)
-        mock(renamed_organization).update!
-        subject
+        context "and an organization is not given" do
+          it { expect { subject }.to raise_error(CF::UserError, "No organizations.") }
+        end
       end
-    end
 
-    context 'when no name is provided, but an organization is' do
-      let(:given) { { :organization => renamed_organization.name } }
+      context "when there are organizations" do
+        let(:renamed_organization) { organizations.first }
+
+        context "when the defaults are used" do
+          it "asks for the organization and new name and renames" do
+            mock_ask("Rename which organization?", anything) { renamed_organization }
+            mock_ask("New name") { new_name }
+            renamed_organization.should_receive(:name=).with(new_name)
+            renamed_organization.should_receive(:update!)
+            subject
+          end
+        end
+
+        context "when no name is provided, but an organization is" do
+          let(:given) { {:organization => renamed_organization.name} }
 
-      it 'asks for the new name and renames' do
-        dont_allow_ask("Rename which organization?", anything)
-        mock_ask("New name") { new_name }
-        mock(renamed_organization).name=(new_name)
-        mock(renamed_organization).update!
-        subject
-      end
-    end
+          it "asks for the new name and renames" do
+            dont_allow_ask("Rename which organization?", anything)
+            mock_ask("New name") { new_name }
+            renamed_organization.should_receive(:name=).with(new_name)
+            renamed_organization.should_receive(:update!)
+            subject
+          end
+        end
 
-    context 'when an organization is provided and a name' do
-      let(:inputs) { { :organization => renamed_organization, :name => new_name } }
+        context "when an organization is provided and a name" do
+          let(:inputs) { {:organization => renamed_organization, :name => new_name} }
 
-      it 'renames the organization' do
-        mock(renamed_organization).update!
-        subject
-      end
+          it "renames the organization" do
+            renamed_organization.should_receive(:update!)
+            subject
+          end
 
-      it 'displays the progress' do
-        mock_with_progress("Renaming to #{new_name}")
-        mock(renamed_organization).update!
+          it "displays the progress" do
+            mock_with_progress("Renaming to #{new_name}")
+            renamed_organization.should_receive(:update!)
 
-        subject
-      end
+            subject
+          end
 
-      context 'and the name already exists' do
-        it 'fails' do
-          mock(renamed_organization).update! { raise CFoundry::OrganizationNameTaken.new("Bad error", 200) }
-          expect { subject }.to raise_error(CFoundry::OrganizationNameTaken)
+          context "and the name already exists" do
+            it "fails" do
+              renamed_organization.should_receive(:update!) { raise CFoundry::OrganizationNameTaken.new("Bad error", 200) }
+              expect { subject }.to raise_error(CFoundry::OrganizationNameTaken)
+            end
+          end
         end
       end
     end