trucker-cli 0.0.1

data/spec/cf/cli/domain/map_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+module CF
+  module Domain
+    describe Map do
+      before do
+        stub_client_and_precondition
+      end
+
+      let(:client) do
+        build(:client).tap do |client|
+          client.stub(
+            :current_organization => organization,
+            :current_space => space,
+            :spaces => [space],
+            :organizations => [organization],
+            :domains => domains)
+        end
+      end
+      let(:organization) { build(:organization) }
+      let(:space) { build(:space, :organization => organization) }
+      let(:domain) { build(:domain, :name => domain_name) }
+      let(:domain_name) { "some.domain.com" }
+      let(:domains) { [domain] }
+
+      shared_examples_for "binding a domain to a space" do
+        it "adds the domain to the space's organization" do
+          space.organization.should_receive(:add_domain).with(domain)
+          space.stub(:add_domain)
+          subject
+        end
+
+        it "adds the domain to the space" do
+          space.organization.stub(:add_domain)
+          space.should_receive(:add_domain).with(domain)
+          subject
+        end
+      end
+
+      shared_examples_for "binding a domain to an organization" do
+        it "does NOT add the domain to a space" do
+          space.class.any_instance.should_not_receive(:add_domain).with(domain)
+        end
+
+        it "adds the domain to the organization" do
+          organization.should_receive(:add_domain).with(domain)
+          subject
+        end
+      end
+
+      shared_examples_for "mapping a domain to a space" do
+        context "when the domain does NOT exist" do
+          let(:domains) { [] }
+
+          before do
+            client.stub(:domain) { domain }
+            domain.stub(:create!)
+          end
+
+          it "creates the domain" do
+            space.organization.stub(:add_domain)
+            space.should_receive(:add_domain).with(domain)
+
+            domain.should_receive(:create!)
+            subject
+            expect(domain.name).to eq domain_name
+            expect(domain.owning_organization).to eq organization
+          end
+
+          include_examples "binding a domain to a space"
+        end
+
+        context "when the domain already exists" do
+          include_examples "binding a domain to a space"
+        end
+      end
+
+      context "when a domain and a space are passed" do
+        subject { cf %W[map-domain #{domain.name} --space #{space.name}] }
+        before { organization.stub(:spaces).and_return([space]) }
+
+        include_examples "mapping a domain to a space"
+      end
+
+      context "when a domain and an organization are passed" do
+        subject { cf %W[map-domain #{domain.name} --organization #{organization.name}] }
+
+        context "and the domain does NOT exist" do
+          let(:domains) { [] }
+
+          before do
+            client.stub(:domain) { domain }
+            domain.stub(:create!)
+            organization.stub(:add_domain)
+          end
+
+          include_examples "binding a domain to an organization"
+
+          it "creates the domain" do
+            domain.should_receive(:create!)
+            subject
+            expect(domain.name).to eq domain_name
+          end
+
+          context "and the --shared option is passed" do
+            subject { cf %W[map-domain #{domain.name} --organization #{organization.name} --shared] }
+
+            it "adds the domain to the organization" do
+              organization.should_receive(:add_domain).with(domain)
+              subject
+            end
+
+            it "does not add the domain to a specific organization" do
+              domain.stub(:create!)
+              subject
+              expect(domain.owning_organization).to be_nil
+            end
+          end
+        end
+
+        context "and the domain already exists" do
+          include_examples "binding a domain to an organization"
+        end
+      end
+
+      context "when a domain, organization, and space is passed" do
+        subject { cf %W[map-domain #{domain.name} --space #{space.name} --organization #{organization.name}] }
+        before { organization.stub(:spaces).and_return([space]) }
+
+        include_examples "mapping a domain to a space"
+      end
+
+      context "when only a domain is passed" do
+        subject { cf %W[map-domain #{domain.name}] }
+
+        include_examples "mapping a domain to a space"
+      end
+    end
+  end
+end

data/spec/cf/cli/domain/unmap_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+module CF
+  module Domain
+    describe Unmap do
+      before do
+        stub_client_and_precondition
+      end
+
+      let(:client) do
+        build(:client).tap do |client|
+          client.stub(
+            :current_space => space,
+            :spaces => [space],
+            :organizations => [organization],
+            :domains => [domain])
+        end
+      end
+      let(:organization) { build(:organization) }
+      let(:space) { build(:space, :organization => organization) }
+      let(:domain) { build(:domain, :name => "some.domain.com") }
+
+      context "when the --delete flag is given" do
+        subject { cf %W[unmap-domain #{domain.name} --delete] }
+
+        it "asks for a confirmation" do
+          should_ask("Really delete #{domain.name}?", :default => false) { false }
+          domain.stub(:delete!)
+          subject
+        end
+
+        context "and the user answers 'no' to the confirmation" do
+          it "does NOT delete the domain" do
+            stub_ask("Really delete #{domain.name}?", anything) { false }
+            domain.should_not_receive(:delete!)
+            subject
+          end
+        end
+
+        context "and the user answers 'yes' to the confirmation" do
+          it "deletes the domain" do
+            stub_ask("Really delete #{domain.name}?", anything) { true }
+            domain.should_receive(:delete!)
+            subject
+          end
+        end
+      end
+
+      context "when a space is given" do
+        subject { cf %W[unmap-domain #{domain.name} --space #{space.name}] }
+
+        it "unmaps the domain from the space" do
+          space.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
+
+      context "when an organization is given" do
+        subject { cf %W[unmap-domain #{domain.name} --organization #{organization.name}] }
+
+        it "unmaps the domain from the organization" do
+          organization.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
+
+      context "when only the domain is given" do
+        subject { cf %W[unmap-domain #{domain.name}] }
+
+        it "unmaps the domain from the current space" do
+          client.current_space.should_receive(:remove_domain).with(domain)
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/help_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+module CF
+  describe "Help"  do
+    let(:global) { {} }
+    let(:given) { {} }
+    let(:inputs) { {:app => apps[0]} }
+    let(:apps) { [build(:app)] }
+
+
+    subject do
+      capture_output { Mothership.new.invoke(:help) }
+    end
+
+    it "prints the cf version in the first line" do
+      subject
+      stdout.rewind
+      expect(stdout.readlines.first).to match /Cloud Foundry Command Line Interface, version \[#{CF::VERSION}\]\n/
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+module CF
+  module Organization
+    describe Create do
+      let(:client) { build(:client) }
+      before { stub_client_and_precondition }
+
+      describe "metadata" do
+        subject(:command) { Mothership.commands[:create_org] }
+
+        its(:description) { should == "Create an organization" }
+        it { expect(Mothership::Help.group(:organizations)).to include(command) }
+        its(:arguments) { should == [{type: :optional, value: nil, name: :name}] }
+
+        include_examples "inputs must have descriptions"
+      end
+
+      describe "running the command" do
+        let(:new_org) { build(:organization) }
+        let(:current_user) { build(:user) }
+
+        before do
+          client.stub(organization: new_org)
+          client.stub(current_user: current_user)
+
+          @command_args = ["create-org", new_org.name]
+        end
+
+        context "when the organization already exists" do
+          let(:existing_org) { build(:organization, name: new_org.name) }
+
+          before do
+            new_org.stub(:create!).and_raise(CFoundry::OrganizationNameTaken)
+          end
+
+          context "when --find-if-exists is given" do
+            before { @command_args << "--find-if-exists" }
+            before { client.stub(:organization_by_name).with(new_org.name).and_return(existing_org) }
+
+            context "when --target is given" do
+              before { @command_args << "--target" }
+
+              it "switches them to the existing organization" do
+                mock_invoke :target, organization: existing_org
+                cf @command_args
+              end
+            end
+
+            context "when --target is NOT given" do
+              it "does not actively switch to the existing organization" do
+                dont_allow_invoke :target
+                cf @command_args
+              end
+            end
+          end
+
+          context "when --find-if-exists is NOT given" do
+            before { @command_args << "--target" }
+
+            context "when --target is given" do
+              it "raises an exception" do
+                expect { cf @command_args }.to raise_error(CFoundry::OrganizationNameTaken)
+              end
+            end
+
+            context "when --target is NOT given" do
+              it "raises an exception" do
+                expect { cf @command_args }.to raise_error(CFoundry::OrganizationNameTaken)
+              end
+            end
+          end
+        end
+
+        context "when the organization DOES NOT already exist" do
+          before do
+            new_org.stub(:create!)
+          end
+
+          context "when --find-if-exists is given" do
+            before { @command_args << "--find-if-exists" }
+
+            context "when --target is given" do
+              before { @command_args << "--target" }
+
+              it "switches them to the new organization" do
+                mock_invoke :target, organization: new_org
+                cf @command_args
+              end
+            end
+
+            context "when --target is NOT given" do
+              it "does not actively switch to the existing organization" do
+                dont_allow_invoke :target
+                cf @command_args
+              end
+            end
+          end
+
+          context "when --find-if-exists is NOT given" do
+            context "when --target is given" do
+              before { @command_args << "--target" }
+
+              it "switches them to the new organization" do
+                mock_invoke :target, organization: new_org
+                cf @command_args
+              end
+            end
+
+            context "when --target is NOT given" do
+              it "does not actively switch to the existing organization" do
+                dont_allow_invoke :target
+                cf @command_args
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+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) { build(:organization, :name => "MyOrg") }
+        let(:organizations) { [organization] }
+
+        let(:client) { build(:client) }
+
+        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)
+          client.stub(:organizations).and_return(organizations)
+          client.stub(:organizations_first_page).and_return(organizations)
+        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 }
+            should_ask("Really delete #{organization.name}?", {:default => false}) { true }
+
+            subject
+          end
+        end
+
+        context "when deleting the last organization" do
+          before do
+            client.stub(:organizations_first_page).and_return([])
+          end
+
+          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, build(:organization)] }
+
+          before do
+            client.stub(:current_organization).and_return(organization)
+          end
+
+          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
+end