vmc 0.5.0.rc4 → 0.5.0

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

@@ -1,35 +1,31 @@
 require 'spec_helper'
 
-describe VMC::Domain::Unmap do
-  let(:global) { { :color => false } }
-  let(:given) { {} }
-  let(:client) { fake_client :current_organization => organization, :current_space => space }
-  let!(:cli) { described_class.new }
-
-  before do
-    stub(cli).client { client }
-    stub_output(cli)
+command VMC::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) }
+  let(:organization) { fake(:organization, :spaces => [space]) }
   let(:space) { fake(:space) }
-  let(:domain) { fake(:domain, :name => domain_name) }
-  let(:domain_name) { "some.domain.com" }
-
-  subject { invoke_cli(cli, :unmap_domain, inputs, given, global) }
+  let(:domain) { fake(:domain, :name => "some.domain.com") }
 
   context "when the --delete flag is given" do
-    let(:inputs) { { :domain => domain, :delete => true } }
+    subject { vmc %W[unmap-domain #{domain.name} --delete] }
 
     it "asks for a confirmation" do
-      mock_ask("Really delete #{domain_name}?", :default => false) { false }
+      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 }
+        stub_ask("Really delete #{domain.name}?", anything) { false }
         dont_allow(domain).delete!
         subject
       end
@@ -37,7 +33,7 @@ describe VMC::Domain::Unmap do
 
     context "and the user answers 'yes' to the confirmation" do
       it "deletes the domain" do
-        stub_ask("Really delete #{domain_name}?", anything) { true }
+        stub_ask("Really delete #{domain.name}?", anything) { true }
         mock(domain).delete!
         subject
       end
@@ -45,7 +41,7 @@ describe VMC::Domain::Unmap do
   end
 
   context "when a space is given" do
-    let(:inputs) { { :domain => domain, :space => space } }
+    subject { vmc %W[unmap-domain #{domain.name} --space #{space.name}] }
 
     it "unmaps the domain from the space" do
       mock(space).remove_domain(domain)
@@ -54,7 +50,7 @@ describe VMC::Domain::Unmap do
   end
 
   context "when an organization is given" do
-    let(:inputs) { { :domain => domain, :organization => organization } }
+    subject { vmc %W[unmap-domain #{domain.name} --organization #{organization.name}] }
 
     it "unmaps the domain from the organization" do
       mock(organization).remove_domain(domain)
@@ -63,11 +59,11 @@ describe VMC::Domain::Unmap do
   end
 
   context "when only the domain is given" do
-    let(:inputs) { { :domain => domain } }
+    subject { vmc %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
+end

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

@@ -1,25 +1,19 @@
 require 'spec_helper'
 
-describe VMC::Route::Map do
-  let(:inputs) { {} }
-  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
+command VMC::Route::Map do
+  let(:client) { fake_client(:apps => apps, :routes => routes) }
 
-  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(:space_domains) { [] }
+  let(:app) { fake(:app, :space => space, :name => "app-name") }
+  let(:space) { fake(:space, :domains => space_domains) }
+  let(:domain) { fake(:domain) }
 
-  subject { invoke_cli(cli, :map, inputs, given, global) }
+  let(:apps) { [app] }
+  let(:routes) { [] }
+  let(:domains) { [domain] }
+
+  let(:space_domains) { domains }
+
+  let(:host_name) { "some-host" }
 
   context 'when targeting v2' do
     shared_examples "mapping the route to the app" do
@@ -27,8 +21,11 @@ describe VMC::Route::Map 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) }
+          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)
@@ -46,8 +43,8 @@ describe VMC::Route::Map do
           end
 
           it 'indicates that it is creating a route' do
-            mock(cli).print("Creating route #{host_name}.#{domain_name}")
             subject
+            expect(output).to say("Creating route #{host_name}.#{domain.name}")
           end
 
           it "creates the route in the app's space" do
@@ -59,8 +56,8 @@ describe VMC::Route::Map do
           end
 
           it 'indicates that it is binding the route' do
-            mock(cli).print("Binding #{host_name}.#{domain_name} to app-name")
             subject
+            expect(output).to say("Binding #{host_name}.#{domain.name} to #{app.name}")
           end
 
           it 'binds the route to the app' do
@@ -72,15 +69,14 @@ describe VMC::Route::Map do
     end
 
     context 'when an app is specified' do
-      let(:inputs) { { :domain => domain, :host => host_name, :app => app } }
+      subject { vmc %W[map #{app.name} #{host_name} #{domain.name}] }
 
       context 'and the domain is not already mapped to the space' do
         let(:space_domains) { [] }
-        let(:inputs) { { :app => app } }
-        let(:given) { { :domain => "some-bad-domain" }}
 
         it 'indicates that the domain is invalid' do
-          expect { subject }.to raise_error(VMC::UserError, /Unknown domain/)
+          subject
+          expect(error_output).to say("Unknown domain")
         end
       end
 
@@ -88,10 +84,11 @@ describe VMC::Route::Map do
     end
 
     context 'when an app is not specified' do
-      let(:inputs) { { :domain => domain, :host => host_name } }
       let(:space_domains) { [domain] }
       let(:new_route) { fake(:route) }
 
+      subject { vmc %W[map --host #{host_name} #{domain.name}] }
+
       before { stub_ask("Which application?", anything) { app } }
 
       it 'asks for an app' do
@@ -106,9 +103,10 @@ describe VMC::Route::Map do
     end
 
     context "when a host is not specified" do
-      let(:inputs) { { :domain => domain, :app => app } }
       let(:new_route) { fake(:route) }
 
+      subject { vmc %W[map #{app.name} #{domain.name}] }
+
       before do
         stub(client).route { new_route }
         stub(app).add_route
@@ -124,10 +122,14 @@ describe VMC::Route::Map do
   end
 
   context 'when targeting v1' do
-    let(:given) { { :domain => "foo.bar.com" } }
-    let(:app) { v1_fake :app, :name => "foo" }
     let(:client) { v1_fake_client }
-    let(:inputs) { { :app => app } }
+    let(:app) { v1_fake :app, :name => "foo" }
+
+    subject { vmc %W[map #{app.name} foo.bar.com] }
+
+    before do
+      stub(client).app_by_name("foo") { app }
+    end
 
     it "adds the domain to the app's urls" do
       stub(app).update!

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

@@ -1,11 +1,8 @@
 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 }
+command VMC::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 ) }
@@ -14,13 +11,6 @@ describe VMC::Route::Unmap do
   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] }
 
@@ -42,11 +32,9 @@ describe VMC::Route::Unmap do
 
   context 'when targeting v2' do
     context "when an app and a url are specified" do
-      let(:given) { { :url => url } }
-      let(:inputs) { { :app => app } }
+      subject { vmc %W[unmap #{url} #{app.name}] }
 
       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) }
 
@@ -58,7 +46,8 @@ describe VMC::Route::Unmap do
 
       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/)
+          subject
+          expect(error_output).to say("Unknown route")
         end
       end
     end
@@ -67,9 +56,8 @@ describe VMC::Route::Unmap 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) }
+      subject { vmc %W[unmap --app #{app.name}] }
 
       it "asks the user to select from the app's urls" do
         mock_ask("Which URL?", anything) do |_, opts|
@@ -77,6 +65,8 @@ describe VMC::Route::Unmap do
           route
         end
 
+        stub(app).remove_route(anything)
+
         subject
       end
 
@@ -91,7 +81,8 @@ describe VMC::Route::Unmap 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 } }
+
+      subject { vmc %W[unmap --all --app #{app.name}] }
 
       it "unmaps all routes from the given app" do
         mock(app).remove_route(route)
@@ -103,8 +94,8 @@ describe VMC::Route::Unmap do
     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 } }
+
+      subject { vmc %W[unmap #{url} --delete] }
 
       it "deletes the route" do
         mock(route).delete!
@@ -113,11 +104,18 @@ describe VMC::Route::Unmap do
     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] }
 
+      subject { vmc %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
@@ -147,10 +145,12 @@ describe VMC::Route::Unmap do
     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 } }
+
+      subject { vmc %W[unmap #{url}] }
 
       it "displays an error message" do
-        expect { subject }.to raise_error(VMC::UserError, /Missing either --delete or --app/)
+        subject
+        expect(error_output).to say("Missing either --delete or --app.")
       end
     end
   end
@@ -160,15 +160,20 @@ describe VMC::Route::Unmap do
     let(:app) { CFoundry::V1::App.new("some-app", client) }
     let(:other_url) { "some.other.url.com" }
 
+    before do
+      stub(client).apps { app }
+      stub(client).app_by_name(app.name) { app }
+    end
+
     context "when an app and a url are specified" do
-      let(:given) { { :url => url } }
-      let(:inputs) { { :app => app } }
+      subject { vmc %W[unmap #{url} #{app.name}] }
 
       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/)
+          subject
+          expect(error_output).to say(/URL .* not mapped/)
         end
       end
 
@@ -184,7 +189,8 @@ describe VMC::Route::Unmap do
     end
 
     context "when only an app is specified" do
-      let(:inputs) { { :app => app } }
+      subject { vmc %W[unmap --app #{app.name}] }
+
       before { app.urls = [url, other_url] }
 
       it "asks for the url" do
@@ -202,7 +208,7 @@ describe VMC::Route::Unmap do
     end
 
     context "when an app is specified and the --all option is given" do
-      let(:inputs) { { :app => app, :all => true } }
+      subject { vmc %W[unmap --all --app #{app.name}] }
 
       it "unmaps all routes from the given app" do
         app.urls = ["foo", "bar"]
@@ -212,4 +218,4 @@ describe VMC::Route::Unmap do
       end
     end
   end
-end
+end

data/spec/vmc/cli/start/login_spec.rb

@@ -1,14 +1,8 @@
 require 'spec_helper'
 
-describe VMC::Start::Login do
+command VMC::Start::Login do
   let(:client) { fake_client :organizations => [] }
 
-  before do
-    any_instance_of described_class do |cli|
-      stub(cli).client { client }
-    end
-  end
-
   describe 'metadata' do
     let(:command) { Mothership.commands[:login] }
 
@@ -38,7 +32,7 @@ describe VMC::Start::Login do
   end
 
   describe "running the command" do
-    stub_home_dir_with("new")
+    stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
     let(:auth_token) { CFoundry::AuthToken.new("bearer some-new-access-token", "some-new-refresh-token") }
     let(:tokens_yaml) { YAML.load_file(File.expand_path(tokens_file_path)) }
@@ -46,19 +40,16 @@ describe VMC::Start::Login do
     let(:organizations) { [] }
 
     before do
-      any_instance_of(CFoundry::V2::Client) do |client|
-        stub(client).login("my-username", "my-password") { auth_token }
-        stub(client).login_prompts do
-          {
-            :username => ["text", "Username"],
-            :password => ["password", "8-digit PIN"]
-          }
-        end
-        stub(client).organizations { [] }
+      stub(client).login("my-username", "my-password") { auth_token }
+      stub(client).login_prompts do
+        {
+          :username => ["text", "Username"],
+          :password => ["password", "8-digit PIN"]
+        }
       end
     end
 
-    subject { vmc ["login", "--no-force"] }
+    subject { vmc ["login"] }
 
     it "logs in with the provided credentials and saves the token data to the YAML file" do
       stub_ask("Username", {}) { "my-username" }
@@ -72,7 +63,7 @@ describe VMC::Start::Login do
 
     context "with space and org in the token file" do
       before do
-        write_token_file({:space => "space-id-1", :organization => "organization-id-1"})
+        write_token_file(:space => "space-id-1", :organization => "organization-id-1")
         stub_ask("Username", {}) { "my-username" }
         stub_ask("8-digit PIN", {:echo => "*", :forget => true}) { "my-password" }
       end
@@ -87,21 +78,12 @@ describe VMC::Start::Login do
       end
 
       context "when the user has an organization, but no spaces" do
-        before do
-          stub.proxy(client).organization { organization }
-          any_instance_of(described_class) do |instance|
-            stub(instance).client { client }
-          end
-        end
-
-        let(:client) { fake_client :organizations => organizations,
-          :token => CFoundry::AuthToken.new("bearer some-access-token") }
-        let(:organization) { OpenStruct.new(:name => 'My Org', :guid => 'organization-id-1', :users => [user]) }
-        let(:user) { stub }
-
-        before do
-          stub(organization).spaces { [] }
-        end
+        let(:client) {
+          fake_client :organizations => organizations,
+            :token => CFoundry::AuthToken.new("bearer some-access-token")
+        }
+        let(:organization) { fake :organization, :users => [user] }
+        let(:user) { fake :user }
 
         shared_examples_for :method_clearing_the_token_file do
           it "sets the new organization in the token file" do
@@ -149,9 +131,12 @@ describe VMC::Start::Login do
 
     context 'when there is no target' do
       let(:client) { nil }
-      it_behaves_like "an error that gets passed through",
-        :with_exception => VMC::UserError,
-        :with_message => "Please select a target with 'vmc target'."
+      let(:stub_precondition?) { false }
+
+      it "tells the user to select a target" do
+        subject
+        expect(error_output).to say("Please select a target with 'vmc target'.")
+      end
     end
   end
 end

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

@@ -1,6 +1,10 @@
 require 'spec_helper'
+require "webmock/rspec"
+
+command VMC::Start::Target do
+  let(:client) { fake_client :apps => [app] }
+  let(:app) { fake :app }
 
-describe VMC::Start::Target do
   describe 'metadata' do
     let(:command) { Mothership.commands[:target] }
 
@@ -29,7 +33,7 @@ describe VMC::Start::Target do
   end
 
   describe 'running the command' do
-    stub_home_dir_with("new")
+    stub_home_dir_with { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
 
     context "when the user is authenticated and has an organization" do
       let(:tokens_file_path) { '~/.vmc/tokens.yml' }
@@ -71,15 +75,37 @@ describe VMC::Start::Target do
             subject
           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::Client) do |cli|
+              stub(cli).info { raise CFoundry::TargetRefused, "foo" }
+            end
+
+            subject
+            expect(error_output).to say("Target refused connection.")
+          end
+        end
+
+        context "when the uri is malformed" do
+          it "shows a pretty error message" do
+            any_instance_of(CFoundry::Client) do |cli|
+              stub(cli).info { raise CFoundry::InvalidTarget.new(target) }
+            end
+
+            subject
+            expect(error_output).to say("Invalid target URI.")
+          end
+        end
       end
 
       describe "switching the space" do
-        let(:space_name) { spaces.last.name }
+        let(:space) { spaces.last }
         let(:tokens_yaml) { YAML.load_file(File.expand_path(tokens_file_path)) }
         let(:tokens_file_path) { '~/.vmc/tokens.yml' }
 
         def run_command
-          vmc ["target", "-s", space_name]
+          vmc %W[target -s #{space.name}]
         end
 
         it "should not reprompt for organization" do

data/spec/vmc/cli/user/register_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe VMC::User::Register do
+command VMC::User::Register do
   describe 'metadata' do
     let(:command) { Mothership.commands[:register] }
 
@@ -32,10 +32,6 @@ describe VMC::User::Register do
     let(:score) { :strong }
 
     before do
-      any_instance_of described_class do |cli|
-        stub(cli).client { client }
-        stub(cli).precondition { nil }
-      end
       stub(client).register
       stub(client).base.stub!.password_score(password) { score }
     end
@@ -49,19 +45,17 @@ describe VMC::User::Register do
 
       it 'fails' do
         subject
-        expect(stderr.string).to include "Passwords do not match."
+        expect(error_output).to say("Passwords do not match.")
       end
 
       it "doesn't print out the score" do
         subject
-        expect(stdout.string).not_to include "strength"
+        expect(output).to_not say("strength")
       end
 
       it "doesn't log in or register" do
         dont_allow(client).register
-        any_instance_of(described_class) do |register|
-          dont_allow(register).invoke
-        end
+        dont_allow_invoke
         subject
       end
 
@@ -71,7 +65,7 @@ describe VMC::User::Register do
         it "doesn't verify the password" do
           mock(client).register(email, password)
           subject
-          expect(stderr.string).not_to include "Passwords do not match."
+          expect(error_output).to_not say("Passwords do not match.")
         end
       end
     end
@@ -118,7 +112,7 @@ describe VMC::User::Register do
 
       it 'prints out the password score' do
         subject
-        expect(stderr.string).to include "Your password strength is: weak"
+        expect(error_output).to say("Your password strength is: weak")
       end
 
       it "doesn't register" do
@@ -127,9 +121,7 @@ describe VMC::User::Register do
       end
 
       it "doesn't log in" do
-        any_instance_of(described_class) do |register|
-          dont_allow(register).invoke(:login, :username => email, :password => password)
-        end
+        dont_allow_invoke :login
         subject
       end
     end