vmc 0.5.0.beta.12 → 0.5.0.rc1

data/spec/vmc/cli/app/stats_spec.rb

@@ -57,6 +57,6 @@ describe VMC::App::Stats do
   it 'prints out the stats' do
     subject
     stdout.rewind
-    expect(stdout.readlines.last).to match /.*0\s+0\.0% of\s+cores\s+29\.9M of 288M\s+14\.9M of 256M.*/
+    expect(stdout.readlines.last).to match /.*0\s+0\.0%\s+29\.9M of 288M\s+14\.9M of 256M.*/
   end
 end

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

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe VMC::Route::Map do
+  let(:inputs) { {} }
   let(:global) { { :color => false } }
   let(:given) { {} }
   let(:client) { fake_client }
@@ -16,7 +17,6 @@ describe VMC::Route::Map do
   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) }
@@ -72,55 +72,23 @@ describe VMC::Route::Map do
     end
 
     context 'when an app is specified' do
-      let(:inputs) { { :url => url, :app => app } }
+      let(:inputs) { { :domain => domain, :host => host_name, :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 } }
+        let(:space_domains) { [] }
+        let(:inputs) { { :app => app } }
+        let(:given) { { :domain => "some-bad-domain" }}
 
-      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/)
+          expect { subject }.to raise_error(VMC::UserError, /Unknown 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
+      include_examples "mapping the route to the app"
     end
 
-    context 'when neither an app nor a space is specified' do
-      let(:inputs) { { :url => url } }
+    context 'when an app is not specified' do
+      let(:inputs) { { :domain => domain, :host => host_name } }
       let(:space_domains) { [domain] }
       let(:new_route) { fake(:route) }
 
@@ -136,7 +104,35 @@ describe VMC::Route::Map do
 
       include_examples "mapping the route to the app"
     end
+
+    context "when a host is not specified" do
+      let(:inputs) { { :domain => domain, :app => app } }
+      let(:new_route) { fake(:route) }
+
+      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
 
-  context 'when targeting v1'
+  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 } }
+
+    it "adds the domain to the app's urls" do
+      stub(app).update!
+      subject
+      expect(app.urls).to include "foo.bar.com"
+    end
+  end
 end

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

@@ -14,7 +14,7 @@ describe VMC::Start::Info do
   end
 
   let(:target_info) do
-    {:description => "Some description",
+    { :description => "Some description",
       :version => 2,
       :support => "http://example.com"
     }
@@ -24,6 +24,18 @@ describe VMC::Start::Info do
     any_instance_of described_class do |cli|
       stub(cli).client { client }
     end
+
+    described_class.class_eval do
+      def wrap_errors
+        yield
+      end
+    end
+  end
+
+  after do
+    described_class.class_eval do
+      remove_method :wrap_errors
+    end
   end
 
   describe 'metadata' do
@@ -150,4 +162,12 @@ describe VMC::Start::Info do
       expect(stdout.readline).to match /Getting services.*OK/
     end
   end
+
+  context 'when there is no target' do
+    let(:client) { nil }
+
+    it "tells the user to run 'vmc target'" do
+      expect { subject }.to raise_error(VMC::UserError)
+    end
+  end
 end

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

@@ -1,6 +1,26 @@
 require 'spec_helper'
 
 describe VMC::Start::Login do
+  let(:client) { fake_client :organizations => [] }
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).client { client }
+    end
+
+    described_class.class_eval do
+      def wrap_errors
+        yield
+      end
+    end
+  end
+
+  after do
+    described_class.class_eval do
+      remove_method :wrap_errors
+    end
+  end
+
   describe 'metadata' do
     let(:command) { Mothership.commands[:login] }
 
@@ -43,15 +63,13 @@ describe VMC::Start::Login do
     after { FileUtils.rm_rf home_dir }
 
     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
 
@@ -67,5 +85,13 @@ describe VMC::Start::Login do
       expect(tokens_yaml["https://api.some-domain.com"][:token]).to eq("bearer some-new-access-token")
       expect(tokens_yaml["https://api.some-domain.com"][:refresh_token]).to eq("some-new-refresh-token")
     end
+
+    context 'when there is no target' do
+      let(:client) { nil }
+
+      it "tells the user to run 'vmc target'" do
+        expect { subject }.to raise_error(VMC::UserError)
+      end
+    end
   end
-end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe VMC::Start::Logout do
+  let(:client) { fake_client }
+
+  before do
+    any_instance_of described_class do |cli|
+      stub(cli).client { client }
+    end
+
+    described_class.class_eval do
+      def wrap_errors
+        yield
+      end
+    end
+  end
+
+  after do
+    described_class.class_eval do
+      remove_method :wrap_errors
+    end
+  end
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:logout] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Log out from the target" }
+      it { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+  end
+
+  describe "running the command" do
+    subject { vmc ["logout"] }
+
+    context "when there is a target" do
+      let(:info) { { client.target => "x", "abc" => "x" } }
+
+      before do
+        any_instance_of VMC::CLI do |cli|
+          stub(cli).targets_info { info }
+          stub(cli).client_target { client.target }
+        end
+      end
+
+      it "removes the target info from the tokens file" do
+        expect {
+          subject
+        }.to change { info }.to("abc" => "x")
+      end
+    end
+
+    context "when there is no target" do
+      let(:client) { nil }
+
+      it "tells the user to run 'vmc target'" do
+        expect { subject }.to raise_error(VMC::UserError)
+      end
+    end
+  end
+end
+

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

@@ -39,7 +39,7 @@ describe VMC::User::Passwd do
       stub(client).logged_in? { true }
       stub(client).current_user { user }
       stub(client).register
-      stub(client).base.stub!.uaa.stub!.password_score(new_password) { score }
+      stub(client).password_score(new_password) { score }
     end
 
     subject { vmc %W[passwd --password #{old_password} --new-password #{new_password} --verify #{verify_password} --no-force --debug] }

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

@@ -37,7 +37,7 @@ describe VMC::User::Register do
         stub(cli).precondition { nil }
       end
       stub(client).register
-      stub(client).base.stub!.uaa.stub!.password_score(password) { score }
+      stub(client).password_score(password) { score }
     end
 
     subject { vmc %W[register --email #{email} --password #{password} --verify #{verify_password} --#{bool_flag(:login)} --#{bool_flag(:force)}] }

data/spec/vmc/cli_spec.rb

@@ -1,48 +1,250 @@
 require 'spec_helper'
 
+class NoWrapErrorsDummy < VMC::CLI
+  def wrap_errors
+    yield
+  end
+end
+
 describe VMC::CLI do
-  let(:cmd) { Class.new(VMC::CLI).new }
-  let(:cli) { VMC::CLI.new }
+  let(:context) { NoWrapErrorsDummy.new }
+  let(:command) { nil }
 
-  describe '#execute' do
+  describe "#wrap_errors" do
+    let(:context) { VMC::CLI.new }
     let(:inputs) { {} }
 
     subject do
       capture_output do
-        stub(cmd).input { inputs }
-        cmd.execute(nil, [])
+        stub(context).input { inputs }
+        context.wrap_errors { action.call }
+      end
+    end
+
+    shared_examples_for "an error that's obvious to the user" do |options|
+      message = options[:with_message]
+
+      it "prints the message" do
+        subject
+        expect(stderr.string).to include message
+      end
+
+      it "sets the exit code to 1" do
+        mock(context).exit_status(1)
+        subject
+      end
+
+      it "does not mention ~/.vmc/crash" do
+        subject
+        expect(stderr.string).to_not include VMC::CRASH_FILE
+      end
+    end
+
+    shared_examples_for "an error that gets passed through" do |options|
+      exception = options[:with_exception]
+
+      it "reraises the error" do
+        expect { subject }.to raise_error(exception)
+      end
+    end
+
+    context "with a CFoundry::Timeout" do
+      let(:action) { proc { raise CFoundry::Timeout.new(123, "fizzbuzz") } }
+
+      it_behaves_like "an error that's obvious to the user",
+        :with_message => "fizzbuzz"
+    end
+
+    context "with a UserError" do
+      let(:action) { proc { context.fail "foo bar" } }
+
+      it_behaves_like "an error that's obvious to the user",
+        :with_message => "foo bar"
+
+      it "saves it in the crashlog" do
+        mock(context).log_error(anything)
+        subject
       end
     end
 
-    it 'wraps Timeout::Error with a more friendly message' do
-      stub(cmd).precondition { raise CFoundry::Timeout.new("GET", "/foo") }
+    context "with a SystemExit" do
+      let(:action) { proc { exit 1 } }
 
-      mock(cmd).err 'GET /foo timed out'
-      subject
+      it_behaves_like "an error that gets passed through",
+        :with_exception => SystemExit
     end
 
-    context 'when the debug flag is on' do
-      let(:inputs) { {:debug => true} }
+    context "with a Mothership::Error" do
+      let(:action) { proc { raise Mothership::Error } }
 
-      it 'reraises' do
-        stub(cmd).precondition { raise StandardError.new }
-        expect { subject }.to raise_error(StandardError)
+      it_behaves_like "an error that gets passed through",
+        :with_exception => Mothership::Error
+    end
+
+    context "with an Interrupt" do
+      let(:action) { proc { raise Interrupt } }
+
+      it "sets the exit code to 130" do
+        mock(context).exit_status(130)
+        subject
       end
     end
 
-    context 'when the debug flag is off' do
-      it 'outputs the crash log message' do
-        stub(cmd).precondition { raise StandardError.new }
-        mock(cmd).err /StandardError: StandardError\nFor more information, see .+\.vmc\/crash/
+    context "with a CFoundry authentication error" do
+      let(:action) { proc { raise CFoundry::InvalidAuthToken.new("foo bar") } }
+      let(:asked) { false }
 
-        expect { subject }.not_to raise_error(StandardError)
+      before do
+        $vmc_asked_auth = asked
+      end
+
+      it "tells the user they are not authenticated" do
+        stub(context).invoke(:login)
+        subject
+        expect(stdout.string).to include "Not authenticated! Try logging in:"
+      end
+
+      it "asks the user to log in" do
+        mock(context).invoke(:login)
+        subject
+      end
+
+      context "and after logging in they got another authentication error" do
+        let(:asked) { true }
+
+        it "does not ask them to log in" do
+          dont_allow(context).invoke(:login)
+          subject
+        end
+
+        it_behaves_like "an error that's obvious to the user",
+          :with_message => "Denied: foo bar"
+      end
+    end
+
+    context "with an arbitrary exception" do
+      let(:action) { proc { raise "foo bar" } }
+
+      it "logs the error" do
+        mock(context).log_error(anything)
+        subject
+      end
+
+      it "prints the message" do
+        subject
+        expect(stderr.string).to include "RuntimeError: foo bar"
+      end
+
+      it "sets the exit code to 1" do
+        mock(context).exit_status(1)
+        subject
+      end
+
+      it "tells the user to check ~/.vmc/crash" do
+        subject
+        expect(stderr.string).to include VMC::CRASH_FILE
+      end
+
+      context "when we are debugging" do
+        let(:inputs) { { :debug => true } }
+
+        it_behaves_like "an error that gets passed through",
+          :with_exception => RuntimeError
+      end
+    end
+  end
+
+  describe '#execute' do
+    let(:inputs) { {} }
+    let(:client) { fake_client }
+
+    before do
+      any_instance_of(VMC::CLI) do |cli|
+        stub(cli).client { client }
+      end
+    end
+
+    subject do
+      capture_output do
+        stub(context).input { inputs }
+        context.execute(command, [])
+      end
+    end
+
+    describe "token refreshing" do
+      let(:context) { TokenRefreshDummy.new }
+      let(:command) { Mothership.commands[:refresh_token] }
+      let(:auth_token) { CFoundry::AuthToken.new("old-header") }
+      let(:new_auth_token) { CFoundry::AuthToken.new("new-header") }
+
+      class TokenRefreshDummy < NoWrapErrorsDummy
+        class << self
+          attr_accessor :new_token
+        end
+
+        def precondition; end
+
+        desc "XXX"
+        def refresh_token
+          if client
+            client.token = self.class.new_token
+          end
+        end
+      end
+
+      context "when there is a target" do
+        before do
+          TokenRefreshDummy.new_token = nil
+          client.token = auth_token
+        end
+
+        context "when the token refreshes" do
+          it "saves to the target file" do
+            any_instance_of(TokenRefreshDummy) do |trd|
+              trd.new_token = new_auth_token
+
+              stub(trd).target_info { {} }
+              mock(trd).save_target_info(anything) do |info|
+                expect(info[:token]).to eq new_auth_token.auth_header
+              end
+            end
+
+            subject
+          end
+        end
+
+        context "but there is no token initially" do
+          let(:auth_token) { nil }
+
+          it "doesn't save the new token because something else probably did" do
+            dont_allow(context).save_target_info(anything)
+            subject
+          end
+        end
+
+        context "and the token becomes nil" do
+          let(:new_auth_token) { nil }
+
+          it "doesn't save the nil token" do
+            dont_allow(context).save_target_info(anything)
+            subject
+          end
+        end
+      end
+
+      context "when there is no target" do
+        let(:client) { nil }
+
+        it "doesn't try to compare the tokens" do
+          expect { subject }.to_not raise_error
+        end
       end
     end
   end
 
   describe '#log_error' do
     subject do
-      cmd.log_error(exception)
+      context.log_error(exception)
       File.read(File.expand_path(VMC::CRASH_FILE))
     end
 
@@ -79,7 +281,7 @@ describe VMC::CLI do
   end
 
   describe "#client_target" do
-    subject { cli.client_target }
+    subject { context.client_target }
 
     context "when a ~/.vmc/target exists" do
       use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
@@ -100,14 +302,14 @@ describe VMC::CLI do
     context "when no target file exists" do
       use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
 
-      it "displays an error to the user" do
-        expect{ subject }.to raise_error(VMC::UserError, /Please select a target/)
+      it "returns nil" do
+        expect(subject).to eq nil
       end
     end
   end
 
   describe "#targets_info" do
-    subject { cli.targets_info }
+    subject { context.targets_info }
 
     context "when a ~/.vmc/tokens.yml exists" do
       use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
@@ -181,7 +383,7 @@ describe VMC::CLI do
     use_fake_home_dir { tmpdir }
 
     before do
-      stub(cli).targets_info do
+      stub(context).targets_info do
         {
           "https://api.some-domain.com" => { :token => "bearer token1" },
           "https://api.some-other-domain.com" => { :token => "bearer token2" }
@@ -193,7 +395,7 @@ describe VMC::CLI do
 
     describe "#save_target_info" do
       it "adds the given target info, and writes the result to ~/.vmc/tokens.yml" do
-        cli.save_target_info({ :token => "bearer token3" }, "https://api.some-domain.com")
+        context.save_target_info({ :token => "bearer token3" }, "https://api.some-domain.com")
         YAML.load_file(File.expand_path("~/.vmc/tokens.yml")).should == {
           "https://api.some-domain.com" => { :token => "bearer token3" },
           "https://api.some-other-domain.com" => { :token => "bearer token2" }
@@ -203,7 +405,7 @@ describe VMC::CLI do
 
     describe "#remove_target_info" do
       it "removes the given target, and writes the result to ~/.vmc/tokens.yml" do
-        cli.remove_target_info("https://api.some-domain.com")
+        context.remove_target_info("https://api.some-domain.com")
         YAML.load_file(File.expand_path("~/.vmc/tokens.yml")).should == {
           "https://api.some-other-domain.com" => { :token => "bearer token2" }
         }
@@ -213,24 +415,32 @@ describe VMC::CLI do
 
   describe "#client" do
     use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
-    before { stub(cli).input { {} } }
+    before { stub(context).input { {} } }
 
     describe "the client's token" do
       it "constructs an AuthToken object with the data from the tokens.yml file" do
-        expect(cli.client.token).to be_a(CFoundry::AuthToken)
-        expect(cli.client.token.auth_header).to eq("bearer some-token")
+        expect(context.client.token).to be_a(CFoundry::AuthToken)
+        expect(context.client.token.auth_header).to eq("bearer some-token")
       end
 
       it "does not assign an AuthToken on the client if there is no token stored" do
-        mock(cli).target_info("some-fake-target") { { :version => 2 } }
-        expect(cli.client("some-fake-target").token).to be_nil
+        mock(context).target_info("some-fake-target") { { :version => 2 } }
+        expect(context.client("some-fake-target").token).to be_nil
       end
     end
 
     describe "the client's version" do
       it "uses the version stored in the yml file" do
 
-        expect(cli.client.version).to eq(2)
+        expect(context.client.version).to eq(2)
+      end
+    end
+
+    context "when there is no target" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+
+      it "returns nil" do
+        expect(context.client).to eq(nil)
       end
     end
   end