cf 0.1.5 → 0.6.0.rc1

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+command CF::Domain::Unmap do
+  let(:client) do
+    fake_client(
+      :current_organization => organization,
+      :current_space => space,
+      :spaces => [space],
+      :organizations => [organization],
+      :domains => [domain])
+  end
+
+  let(:organization) { fake(:organization, :spaces => [space]) }
+  let(:space) { fake(:space) }
+  let(:domain) { fake(: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
+      mock_ask("Really delete #{domain.name}?", :default => false) { false }
+      stub(domain).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 }
+        dont_allow(domain).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 }
+        mock(domain).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
+      mock(space).remove_domain(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
+      mock(organization).remove_domain(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
+      mock(client.current_space).remove_domain(domain)
+      subject
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+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'
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it 'has no arguments' do
+        should be_empty
+      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
+
+  context 'when there are no orgnaizations' 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|
+          dont_allow(orgs).invoke
+        end
+        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
+  end
+
+  context 'when there are organizations' do
+    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
+        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
+
+        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)}/
+        end
+        expect(stdout).to be_eof
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+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
+
+  subject { Mothership.new.invoke(:rename_org, inputs, given, global) }
+
+  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 '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
+        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 }
+        ])
+      end
+    end
+  end
+
+  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 '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
+      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
+
+    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 'displays the progress' do
+        mock_with_progress("Renaming to #{new_name}")
+        mock(renamed_organization).update!
+
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+command CF::Route::Map do
+  let(:client) { fake_client(:apps => apps, :routes => routes) }
+
+  let(:app) { fake(:app, :space => space, :name => "app-name") }
+  let(:space) { fake(:space, :domains => space_domains) }
+  let(:domain) { fake(:domain) }
+
+  let(:apps) { [app] }
+  let(:routes) { [] }
+  let(:domains) { [domain] }
+
+  let(:space_domains) { domains }
+
+  let(:host_name) { "some-host" }
+
+  shared_examples "mapping the route to the app" do
+    context 'and the domain is mapped to the space' do
+      let(:space_domains) { [domain] }
+
+      context 'and the route is mapped to the space' do
+        let(:routes) { [route] }
+        let(:route) do
+          fake(:route, :space => space, :host => host_name,
+               :domain => domain)
+        end
+
+        it 'binds the route to the app' do
+          mock(app).add_route(route)
+          subject
+        end
+      end
+
+      context 'and the route is not mapped to the space' do
+        let(:new_route) { fake(:route) }
+
+        before do
+          stub(client).route { new_route }
+          stub(app).add_route
+          stub(new_route).create!
+        end
+
+        it 'indicates that it is creating a route' do
+          subject
+          expect(output).to say("Creating route #{host_name}.#{domain.name}")
+        end
+
+        it "creates the route in the app's space" do
+          mock(new_route).create!
+          subject
+          expect(new_route.host).to eq host_name
+          expect(new_route.domain).to eq domain
+          expect(new_route.space).to eq space
+        end
+
+        it 'indicates that it is binding the route' do
+          subject
+          expect(output).to say("Binding #{host_name}.#{domain.name} to #{app.name}")
+        end
+
+        it 'binds the route to the app' do
+          mock(app).add_route(new_route)
+          subject
+        end
+      end
+    end
+  end
+
+  context 'when an app is specified' do
+    subject { cf %W[map #{app.name} #{host_name} #{domain.name}] }
+
+    context 'and the domain is not already mapped to the space' do
+      let(:space_domains) { [] }
+
+      it 'indicates that the domain is invalid' do
+        subject
+        expect(error_output).to say("Unknown domain")
+      end
+    end
+
+    include_examples "mapping the route to the app"
+  end
+
+  context 'when an app is not specified' do
+    let(:space_domains) { [domain] }
+    let(:new_route) { fake(:route) }
+
+    subject { cf %W[map --host #{host_name} #{domain.name}] }
+
+    before { stub_ask("Which application?", anything) { app } }
+
+    it 'asks for an app' do
+      stub(client).route { new_route }
+      stub(app).add_route
+      stub(new_route).create!
+      mock_ask("Which application?", anything) { app }
+      subject
+    end
+
+    include_examples "mapping the route to the app"
+  end
+
+  context "when a host is not specified" do
+    let(:new_route) { fake(:route) }
+
+    subject { cf %W[map #{app.name} #{domain.name}] }
+
+    before do
+      stub(client).route { new_route }
+      stub(app).add_route
+      stub(new_route).create!
+    end
+
+    it "creates a route with an empty string as its host" do
+      mock(new_route).create!
+      subject
+      expect(new_route.host).to eq ""
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+command CF::Route::Unmap do
+  let(:client) { fake_client :apps => [app] }
+
+  let(:app){ fake(:app, :space => space, :name => "app-name") }
+  let(:space) { fake(:space, :name => "space-name", :domains => space_domains) }
+  let(:domain) { fake(:domain, :name => domain_name ) }
+  let(:domain_name) { "some-domain.com" }
+  let(:host_name) { "some-host" }
+  let(:url) { "#{host_name}.#{domain_name}" }
+  let(:space_domains) { [domain] }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:delete_service] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Delete a service" }
+      it { expect(Mothership::Help.group(:services, :manage)).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 => :service }])
+      end
+    end
+  end
+
+  context "when an app and a url are specified" do
+    subject { cf %W[unmap #{url} #{app.name}] }
+
+    context "when the given route is mapped to the given app" do
+      let(:app) { fake(:app, :space => space, :name => "app-name", :routes => [route]) }
+      let(:route) { fake(:route, :space => space, :host => host_name, :domain => domain) }
+
+      it "unmaps the url from the app" do
+        mock(app).remove_route(route)
+        subject
+      end
+    end
+
+    context "when the given route is NOT mapped to the given app" do
+      it "displays an error" do
+        subject
+        expect(error_output).to say("Unknown route")
+      end
+    end
+  end
+
+  context "when only an app is specified" do
+    let(:other_route) { fake(:route, :host => "abcd", :domain => domain) }
+    let(:route) { fake(:route, :host => "efgh", :domain => domain) }
+    let(:app) { fake(:app, :space => space, :routes => [route, other_route] )}
+
+    subject { cf %W[unmap --app #{app.name}] }
+
+    it "asks the user to select from the app's urls" do
+      mock_ask("Which URL?", anything) do |_, opts|
+        expect(opts[:choices]).to eq [other_route, route]
+        route
+      end
+
+      stub(app).remove_route(anything)
+
+      subject
+    end
+
+    it "unmaps the selected url from the app" do
+      stub_ask("Which URL?", anything) { route }
+      mock(app).remove_route(route)
+      subject
+    end
+  end
+
+  context "when an app is specified and the --all option is given" do
+    let(:other_route) { fake(:route, :host => "abcd", :domain => domain) }
+    let(:route) { fake(:route, :host => "efgh", :domain => domain) }
+    let(:app) { fake(:app, :routes => [route, other_route]) }
+
+    subject { cf %W[unmap --all --app #{app.name}] }
+
+    it "unmaps all routes from the given app" do
+      mock(app).remove_route(route)
+      mock(app).remove_route(other_route)
+      subject
+    end
+  end
+
+  context "when a url is specified and the --delete option is given" do
+    let(:route) { fake(:route, :host => host_name, :domain => domain) }
+    let(:client) { fake_client :routes => [route] }
+
+    subject { cf %W[unmap #{url} --delete] }
+
+    it "deletes the route" do
+      mock(route).delete!
+      subject
+    end
+  end
+
+  context "when the --delete and --all options are both passed" do
+    let(:other_route) { fake(:route, :host => "abcd", :domain => domain) }
+    let(:route) { fake(:route, :host => "efgh", :domain => domain) }
+    let(:client) { fake_client :routes => [route, other_route] }
+
+    subject { cf %W[unmap --delete --all] }
+
+    before do
+      any_instance_of(route.class) do |route|
+        stub(route).delete!
+      end
+    end
+
+    it "asks if the user really wants to unmap all urls" do
+      mock_ask("Really delete ALL URLS?", :default => false) { false }
+      subject
+    end
+
+    context "when the user responds with a yes" do
+      before { stub_ask("Really delete ALL URLS?", anything) { true } }
+
+      it "deletes all the user's routes" do
+        client.routes.each { |r| mock(r).delete! }
+        subject
+      end
+    end
+
+    context "when the user responds with a no" do
+      before { stub_ask("Really delete ALL URLS?", anything) { false } }
+
+      it "does not delete any routes" do
+        any_instance_of(route.class) do |route|
+          dont_allow(route).delete!
+        end
+        subject
+      end
+    end
+  end
+
+  context "when only a url is passed" do
+    let(:route) { fake(:route, :host => host_name, :domain => domain) }
+    let(:client) { fake_client :routes => [route] }
+
+    subject { cf %W[unmap #{url}] }
+
+    it "displays an error message" do
+      subject
+      expect(error_output).to say("Missing either --delete or --app.")
+    end
+  end
+end