vmc 0.5.0.beta.7 → 0.5.0.beta.10

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

@@ -21,9 +21,7 @@ describe VMC::Organization::Orgs do
   end
 
   subject do
-    with_output_to output do
-      Mothership.new.invoke(:orgs, inputs, given, global)
-    end
+    capture_output { Mothership.new.invoke(:orgs, inputs, given, global) }
   end
 
   describe 'metadata' do
@@ -47,10 +45,9 @@ describe VMC::Organization::Orgs do
 
   it 'should have the correct first two lines' do
     subject
-
-    output.rewind
-    expect(output.readline).to match /Getting organizations.*OK/
-    expect(output.readline).to eq "\n"
+    stdout.rewind
+    expect(stdout.readline).to match /Getting organizations.*OK/
+    expect(stdout.readline).to eq "\n"
   end
 
   context 'when there are no orgnaizations' do
@@ -71,9 +68,9 @@ describe VMC::Organization::Orgs do
       it 'should show only the progress' do
         subject
 
-        output.rewind
-        expect(output.readline).to match /Getting organizations.*OK/
-        expect(output).to be_eof
+        stdout.rewind
+        expect(stdout.readline).to match /Getting organizations.*OK/
+        expect(stdout).to be_eof
       end
     end
   end
@@ -96,15 +93,15 @@ describe VMC::Organization::Orgs do
       it 'displays tabular output with names, spaces and domains' do
         subject
 
-        output.rewind
-        output.readline
-        output.readline
+        stdout.rewind
+        stdout.readline
+        stdout.readline
 
-        expect(output.readline).to match /name\s+spaces\s+domains/
+        expect(stdout.readline).to match /name\s+spaces\s+domains/
         organizations.sort_by(&:name).each do |org|
-          expect(output.readline).to match /#{org.name}\s+#{name_list(org.spaces)}\s+#{name_list(org.domains)}/
+          expect(stdout.readline).to match /#{org.name}\s+#{name_list(org.spaces)}\s+#{name_list(org.domains)}/
         end
-        expect(output).to be_eof
+        expect(stdout).to be_eof
       end
     end
   end

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

@@ -104,7 +104,7 @@ describe VMC::Organization::Rename do
 
       context 'and the name already exists' do
         it 'fails' do
-          mock(renamed_organization).update! { raise CFoundry::OrganizationNameTaken.new(nil, nil, "Bad error", 200) }
+          mock(renamed_organization).update! { raise CFoundry::OrganizationNameTaken.new("Bad error", 200) }
           expect { subject }.to raise_error(CFoundry::OrganizationNameTaken)
         end
       end

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe VMC::Route::Map do
+  let(:global) { { :color => false } }
+  let(:given) { {} }
+  let(:client) { fake_client }
+  let!(:cli) { described_class.new }
+
+  before do
+    stub(cli).client { client }
+    stub_output(cli)
+  end
+
+  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) { [] }
+
+  subject { invoke_cli(cli, :map, inputs, given, global) }
+
+  context 'when targeting v2' do
+    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(:client) { fake_client :routes => [route] }
+          let(:route) { fake(:route, :space => space, :host => host_name, :domain => domain) }
+
+          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
+            mock(cli).print("Creating route #{host_name}.#{domain_name}")
+            subject
+          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
+            mock(cli).print("Binding #{host_name}.#{domain_name} to app-name")
+            subject
+          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
+      let(:inputs) { { :url => url, :app => app } }
+
+      context 'and the domain is not already mapped to the space' do
+        it 'indicates that the domain is invalid' do
+          expect { subject }.to raise_error(VMC::UserError, /Invalid domain/)
+        end
+      end
+
+      include_examples "mapping the route to the app"
+    end
+
+    context 'when a space is specified' do
+      let(:inputs) { { :url => url, :space => space } }
+
+      context 'and the domain is not mapped to the space' do
+        it 'indicates that the domain is invalid' do
+          expect { subject }.to raise_error(VMC::UserError, /Invalid domain/)
+        end
+      end
+
+      context 'and the domain is mapped to the space' do
+        let(:domain) { fake(:domain, :client => client, :name => domain_name ) }
+        let(:new_route) { fake(:route, :host => "new-route-host") }
+
+        before do
+          stub(client).route { new_route }
+          stub(new_route).create!
+          stub(space).domain_by_name(domain_name, anything) { domain }
+        end
+
+        context 'and the route does not exist' do
+          it 'indicates that it is creating a route' do
+            mock(cli).print("Creating route #{host_name}.#{domain_name}")
+            subject
+          end
+
+          it 'creates the route in the given 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
+        end
+      end
+    end
+
+    context 'when neither an app nor a space is specified' do
+      let(:inputs) { { :url => url } }
+      let(:space_domains) { [domain] }
+      let(:new_route) { fake(:route) }
+
+      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
+  end
+
+  context 'when targeting v1'
+end

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

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe VMC::Route::Unmap do
+  let(:global) { { :color => false } }
+  let(:given) { {} }
+  let(:inputs) { {} }
+  let(:client) { fake_client }
+  let!(:cli) { described_class.new }
+  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] }
+
+  before do
+    stub(cli).client { client }
+    stub_output(cli)
+  end
+
+  subject { invoke_cli(cli, :unmap, inputs, given, global) }
+
+  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 targeting v2' do
+    context "when an app and a url are specified" do
+      let(:given) { { :url => url } }
+      let(:inputs) { { :app => app } }
+
+      context "when the given route is mapped to the given app" do
+        let(:client) { fake_client :routes => [route] }
+        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
+          expect { subject }.to raise_error(VMC::UserError, /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] )}
+      let(:inputs) { { :app => app } }
+
+      before { stub(app).remove_route(route) }
+
+      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
+
+        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]) }
+      let(:inputs) { { :app => app, :all => true } }
+
+      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] }
+      let(:given) { { :url => url } }
+      let(:inputs) { { :delete => true } }
+
+      it "deletes the route" do
+        mock(route).delete!
+        subject
+      end
+    end
+
+    context "when the --delete and --all options are both passed" do
+      let(:inputs) { { :delete => true, :all => true } }
+      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] }
+
+      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] }
+      let(:given) { { :url => url } }
+
+      it "displays an error message" do
+        expect { subject }.to raise_error(VMC::UserError, /Missing either --delete or --app/)
+      end
+    end
+  end
+
+  context 'when targeting v1' do
+    let(:client) { CFoundry::V1::Client.new }
+    let(:app) { CFoundry::V1::App.new("some-app", client) }
+    let(:other_url) { "some.other.url.com" }
+
+    context "when an app and a url are specified" do
+      let(:given) { { :url => url } }
+      let(:inputs) { { :app => app } }
+
+      context "when the given url is not mapped to the app" do
+        before { app.urls = [other_url] }
+
+        it "displays an error message" do
+          expect { subject }.to raise_error(VMC::UserError, /URL.*not mapped/)
+        end
+      end
+
+      context "when the given url is mapped to the app" do
+        before { app.urls = [url, other_url] }
+
+        it "unmaps the url from the app" do
+          mock(app).update!
+          subject
+          expect(app.urls).to eq [other_url]
+        end
+      end
+    end
+
+    context "when only an app is specified" do
+      let(:inputs) { { :app => app } }
+      before { app.urls = [url, other_url] }
+
+      it "asks for the url" do
+        mock_ask("Which URL?", :choices => [url, other_url]) { url }
+        stub(app).update!
+        subject
+      end
+
+      it "unmaps the selected url from the app" do
+        stub_ask("Which URL?", anything) { url }
+        mock(app).update!
+        subject
+        expect(app.urls).to eq [other_url]
+      end
+    end
+
+    context "when an app is specified and the --all option is given" do
+      let(:inputs) { { :app => app, :all => true } }
+
+      it "unmaps all routes from the given app" do
+        app.urls = ["foo", "bar"]
+        mock(app).update!
+        subject
+        expect(app.urls).to eq []
+      end
+    end
+  end
+end

data/spec/vmc/cli/service/rename_spec.rb

@@ -95,7 +95,7 @@ describe VMC::Service::Rename do
 
       context 'and the name already exists' do
         it 'fails' do
-          mock(renamed_service).update! { raise CFoundry::ServiceInstanceNameTaken.new nil, nil, "Taken", 200 }
+          mock(renamed_service).update! { raise CFoundry::ServiceInstanceNameTaken.new("Taken", 200) }
           expect { subject }.to raise_error(CFoundry::ServiceInstanceNameTaken)
         end
       end

data/spec/vmc/cli/space/rename_spec.rb

@@ -2,23 +2,18 @@ require 'spec_helper'
 require "vmc/cli/space/rename"
 
 describe VMC::Space::Rename do
-  let(:global) { { :color => false, :quiet => true } }
-  let(:inputs) { {} }
-  let(:given) { {} }
   let(:spaces) { fake_list(:space, 3) }
   let(:organization) { fake(:organization, :spaces => spaces) }
   let(:client) { fake_client(:current_organization => organization, :spaces => spaces) }
   let(:new_name) { "some-new-name" }
 
   before do
-    any_instance_of(VMC::CLI) do |cli|
+    any_instance_of described_class do |cli|
       stub(cli).client { client }
       stub(cli).precondition { nil }
     end
   end
 
-  subject { Mothership.new.invoke(:rename_space, inputs, given, global) }
-
   describe 'metadata' do
     let(:command) { Mothership.commands[:rename_space] }
 
@@ -45,12 +40,19 @@ describe VMC::Space::Rename do
     let(:spaces) { [] }
 
     context 'and a space is given' do
-      let(:given) { { :space => "some-invalid-space" } }
-      it { expect { subject }.to raise_error(VMC::UserError, "Unknown space 'some-invalid-space'.") }
+      subject { vmc %W[rename-space --space some-invalid-space --no-force --no-quiet] }
+      it 'prints out an error message' do
+        subject
+        expect(stderr.string).to include "Unknown space 'some-invalid-space'."
+      end
     end
 
     context 'and a space is not given' do
-      it { expect { subject }.to raise_error(VMC::UserError, "No spaces.") }
+      subject { vmc %W[rename-space --no-force] }
+      it 'prints out an error message' do
+        subject
+        expect(stderr.string).to include "No spaces."
+      end
     end
   end
 
@@ -58,6 +60,8 @@ describe VMC::Space::Rename do
     let(:renamed_space) { spaces.first }
 
     context 'when the defaults are used' do
+      subject { vmc %W[rename-space --no-force --no-quiet] }
+
       it 'asks for the space and new name and renames' do
         mock_ask("Rename which space?", anything) { renamed_space }
         mock_ask("New name") { new_name }
@@ -68,7 +72,7 @@ describe VMC::Space::Rename do
     end
 
     context 'when no name is provided, but a space is' do
-      let(:given) { { :space => renamed_space.name } }
+      subject { vmc %W[rename-space --space #{renamed_space.name} --no-force] }
 
       it 'asks for the new name and renames' do
         dont_allow_ask("Rename which space?", anything)
@@ -80,7 +84,7 @@ describe VMC::Space::Rename do
     end
 
     context 'when a space is provided and a name' do
-      let(:inputs) { { :space => renamed_space, :name => new_name } }
+      subject { vmc %W[rename-space --space #{renamed_space.name} --name #{new_name} --no-force] }
 
       it 'renames the space' do
         mock(renamed_space).update!
@@ -93,13 +97,6 @@ describe VMC::Space::Rename do
 
         subject
       end
-
-      context 'and the name already exists' do
-        it 'fails' do
-          mock(renamed_space).update! { raise CFoundry::SpaceNameTaken.new nil, nil, "Taken", 404 }
-          expect { subject }.to raise_error(CFoundry::SpaceNameTaken)
-        end
-      end
     end
   end
 end