af 0.3.22 → 0.5.0.beta.1

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe VMC::Start::Login do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:login] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Authenticate with the target" }
+      it { expect(Mothership::Help.group(:start)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'flags' do
+      subject { command.flags }
+
+      its(["-o"]) { should eq :organization }
+      its(["--org"]) { should eq :organization }
+      its(["--email"]) { should eq :username }
+      its(["-s"]) { should eq :space }
+    end
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it 'have the correct commands' do
+        should eq [{:type=>:optional, :value=>:email, :name=>:username}]
+      end
+    end
+  end
+
+  describe "running the command" do
+    use_fake_home_dir { home_dir }
+
+    let(:home_dir) do
+      tmp_root = Dir.tmpdir
+      FileUtils.cp_r(File.expand_path("#{SPEC_ROOT}/fixtures/fake_home_dirs/new"), tmp_root)
+      "#{tmp_root}/new"
+    end
+
+    let(:auth_token) { CFoundry::AuthToken.new("bearer some-new-access-token", "some-new-refresh-token") }
+
+    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 { [] }
+      end
+    end
+
+    subject { vmc ["login", "--no-force"] }
+
+    it "logs in with the provided credentials and saves the token data to the YAML file" do
+      stub_ask("Username", {}) { "my-username" }
+      stub_ask("8-digit PIN", { :echo => "*", :forget => true}) { "my-password" }
+
+      subject
+
+      tokens_yaml = YAML.load_file(File.expand_path("~/.af/tokens.yml"))
+      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
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe VMC::User::Create do
+  let(:client) { fake_client }
+
+  before do
+    any_instance_of(described_class) { |cli| stub(cli).client { client } }
+    stub(client).register
+  end
+
+  subject { vmc %W[create-user --#{bool_flag(:force)}] }
+
+  context "when the user is not logged in" do
+    let(:force) { true }
+
+    before do
+      stub(client).logged_in? { false }
+    end
+
+    it "tells the user to log in" do
+      subject
+      expect(stderr.string).to include("Please log in")
+    end
+  end
+
+  context "when the user is logged in" do
+    let(:force) { false }
+
+    before do
+      stub(client).logged_in? { true }
+      stub_ask("Email") { "some-angry-dude@example.com" }
+      stub_ask("Password", anything) { "password1" }
+      stub_ask("Verify Password", anything) { confirmation }
+    end
+
+    context "when the password does not match its confirmation" do
+      let(:confirmation) { "wrong" }
+
+      it "displays an error message" do
+        subject
+        expect(stderr.string).to include("Passwords don't match")
+      end
+    end
+
+    context "when the password matches its confirmation" do
+      let(:confirmation) { "password1" }
+
+      it "creates a user" do
+        mock(client).register("some-angry-dude@example.com", "password1")
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe VMC::User::Passwd do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:passwd] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Update a user's password" }
+      it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it 'have the correct commands (with inconsistent user instead of email)' do
+        should eq [{:type => :optional, :value => nil, :name => :user}]
+      end
+    end
+  end
+
+  describe '#passwd' do
+    let(:client) { fake_client }
+    let(:old_password) { "old" }
+    let(:new_password) { "password" }
+    let(:verify_password) { new_password }
+    let(:score) { :strong }
+    let(:guid) { random_string("my-object-guid") }
+    let(:user_model) { fake_model { attribute :password, :object } }
+    let(:user_object) { user_model.new(guid, client) }
+    let(:user) { user_object.fake(:password => 'foo') }
+
+    before do
+      any_instance_of described_class do |cli|
+        stub(cli).client { client }
+        stub(cli).precondition { nil }
+      end
+      stub(client).logged_in? { true }
+      stub(client).current_user { user }
+      stub(client).register
+      stub(client).base.stub!.uaa.stub!.password_score(new_password) { score }
+    end
+
+    subject { vmc %W[passwd --password #{old_password} --new-password #{new_password} --verify #{verify_password} --no-force --debug] }
+
+    context 'when the passwords dont match' do
+      let(:verify_password) { "other_password" }
+
+      it { should eq 1 }
+
+      it 'fails' do
+        subject
+        expect(stderr.string).to include "Passwords do not match."
+      end
+
+      it "doesn't print out the score" do
+        subject
+        expect(stdout.string).not_to include "strength"
+      end
+
+      it "doesn't log in or register" do
+        dont_allow(user).change_password!
+        subject
+      end
+    end
+
+    context 'when the password is good or strong' do
+      before do
+        stub(user).change_password!
+      end
+
+      it { should eq 0 }
+
+      it 'prints out the password score' do
+        subject
+        expect(stdout.string).to include "Your password strength is: strong"
+      end
+
+      it 'changes the password' do
+        mock(user).change_password!(new_password, old_password)
+        subject
+      end
+    end
+
+    context 'when the password is weak' do
+      let(:score) { :weak }
+
+      it { should eq 1 }
+
+      it 'prints out the password score' do
+        subject
+        expect(stderr.string).to include "Your password strength is: weak"
+      end
+
+      it "doesn't change the password" do
+        dont_allow(user).change_password!
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe VMC::User::Register do
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:register] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Create a user and log in" }
+      it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+    end
+
+    include_examples 'inputs must have descriptions'
+
+    describe 'arguments' do
+      subject { command.arguments }
+      it 'have the correct commands' do
+        should eq [
+          {:type => :optional, :value => nil, :name => :email}
+        ]
+      end
+    end
+  end
+
+  describe '#register' do
+    let(:client) { fake_client }
+    let(:email) { 'a@b.com' }
+    let(:password) { 'password' }
+    let(:verify_password) { password }
+    let(:force) { false }
+    let(:login) { false }
+    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!.uaa.stub!.password_score(password) { score }
+    end
+
+    subject { vmc %W[register --email #{email} --password #{password} --verify #{verify_password} --#{bool_flag(:login)} --#{bool_flag(:force)}] }
+
+    context 'when the passwords dont match' do
+      let(:verify_password) { "other_password" }
+
+      it { should eq 1 }
+
+      it 'fails' do
+        subject
+        expect(stderr.string).to include "Passwords do not match."
+      end
+
+      it "doesn't print out the score" do
+        subject
+        expect(stdout.string).not_to include "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
+        subject
+      end
+
+      context 'and the force flag is passed' do
+        let(:force) { true }
+
+        it "doesn't verify the password" do
+          mock(client).register(email, password)
+          subject
+          expect(stderr.string).not_to include "Passwords do not match."
+        end
+      end
+    end
+
+    context 'when the password is good or strong' do
+      it { should eq 0 }
+
+      it 'prints out the password score' do
+        subject
+        expect(stdout.string).to include "Your password strength is: strong"
+      end
+
+      it 'registers the user' do
+        mock(client).register(email, password)
+        subject
+      end
+
+      context 'and the login flag is true' do
+        let(:login) { true }
+
+        it 'logs in' do
+          any_instance_of(described_class) do |register|
+            mock(register).invoke(:login, :username => email, :password => password)
+          end
+          subject
+        end
+      end
+
+      context 'and the login flag is false' do
+        it "doesn't log in" do
+          any_instance_of(described_class) do |register|
+            dont_allow(register).invoke(:login, :username => email, :password => password)
+          end
+          subject
+        end
+      end
+    end
+
+    context 'when the password is weak' do
+      let(:score) { :weak }
+      let(:login) { true }
+
+      it { should eq 1 }
+
+      it 'prints out the password score' do
+        subject
+        expect(stderr.string).to include "Your password strength is: weak"
+      end
+
+      it "doesn't register" do
+        dont_allow(client).register(email, password)
+        subject
+      end
+
+      it "doesn't log in" do
+        any_instance_of(described_class) do |register|
+          dont_allow(register).invoke(:login, :username => email, :password => password)
+        end
+        subject
+      end
+    end
+
+    context 'when arguments are not passed in the command line' do
+      subject { vmc %W[register --no-force --no-login] }
+
+      it 'asks for the email, password and confirm password' do
+        mock_ask("Email") { email }
+        mock_ask("Password", anything) { password }
+        mock_ask("Confirm Password", anything) { verify_password }
+        subject
+      end
+    end
+  end
+end

data/spec/vmc/cli_spec.rb

@@ -0,0 +1,448 @@
+require 'spec_helper'
+
+class NoWrapErrorsDummy < VMC::CLI
+  def wrap_errors
+    yield
+  end
+end
+
+describe VMC::CLI do
+  let(:context) { NoWrapErrorsDummy.new }
+  let(:command) { nil }
+
+  describe "#wrap_errors" do
+    let(:context) { VMC::CLI.new }
+    let(:inputs) { {} }
+
+    subject do
+      capture_output do
+        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
+
+    context "with a SystemExit" do
+      let(:action) { proc { exit 1 } }
+
+      it_behaves_like "an error that gets passed through",
+        :with_exception => SystemExit
+    end
+
+    context "with a Mothership::Error" do
+      let(:action) { proc { raise Mothership::Error } }
+
+      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 "with a CFoundry authentication error" do
+      let(:action) { proc { raise CFoundry::InvalidAuthToken.new("foo bar") } }
+      let(:asked) { false }
+
+      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
+      context.log_error(exception)
+      File.read(File.expand_path(VMC::CRASH_FILE))
+    end
+
+    context 'when the exception is a normal error' do
+      let(:exception) do
+        error = StandardError.new("gemfiles are kinda hard")
+        error.set_backtrace(["fo/gems/bar", "baz quick"])
+        error
+      end
+
+      it { should include "Time of crash:"}
+      it { should include "gemfiles are kinda hard" }
+      it { should include "bar" }
+      it { should_not include "fo/gems/bar" }
+      it { should include "baz quick" }
+    end
+
+    context 'when the exception is an APIError' do
+      let(:request) { { :method => "GET", :url => "http://api.cloudfoundry.com/foo", :headers => {}, :body => nil } }
+      let(:response) { { :status => 404, :body => "bar", :headers => {} } }
+      let(:exception) do
+        error = CFoundry::APIError.new(nil, nil, request, response)
+        error.set_backtrace(["fo/gems/bar", "baz quick"])
+        error
+      end
+
+      before do
+        stub(response).body {"Response Body"}
+      end
+
+      it { should include "REQUEST: " }
+      it { should include "RESPONSE: " }
+    end
+  end
+
+  describe "#client_target" do
+    subject { context.client_target }
+
+    context "when a ~/.vmc/target exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+      it "returns the target in that file" do
+        expect(subject).to eq "https://api.some-domain.com"
+      end
+    end
+
+    context "when a ~/.vmc_target exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/old" }
+
+      it "returns the target in that file" do
+        expect(subject).to eq "https://api.some-domain.com"
+      end
+    end
+
+    context "when no target file exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+
+      it "returns nil" do
+        expect(subject).to eq nil
+      end
+    end
+  end
+
+  describe "#targets_info" do
+    subject { context.targets_info }
+
+    context "when a ~/.vmc/tokens.yml exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+      it "returns the file's contents as a hash" do
+        expect(subject).to eq({
+          "https://api.some-domain.com" => {
+            :token => "bearer some-token",
+            :version => 2
+          }
+        })
+      end
+    end
+
+    context "when a ~/.vmc_token file exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/old" }
+
+      it "returns the target in that file" do
+        expect(subject).to eq({
+          "https://api.some-domain.com" => {
+            :token => "bearer some-token"
+          }
+        })
+      end
+    end
+
+    context "when no token file exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+
+      it "returns an empty hash" do
+        expect(subject).to eq({})
+      end
+    end
+  end
+
+  describe "#target_info" do
+    subject { VMC::CLI.new.target_info("https://api.some-domain.com") }
+
+    context "when a ~/.vmc/tokens.yml exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+
+      it "returns the info for the given url" do
+        expect(subject).to eq({
+          :token => "bearer some-token",
+          :version => 2
+        })
+      end
+    end
+
+    context "when a ~/.vmc_token file exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/old" }
+
+      it "returns the info for the given url" do
+        expect(subject).to eq({
+          :token => "bearer some-token"
+        })
+      end
+    end
+
+    context "when no token file exists" do
+      use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/no_config" }
+
+      it "returns an empty hash" do
+        expect(subject).to eq({})
+      end
+    end
+  end
+
+  describe "methods that update the token info" do
+    let!(:tmpdir) { Dir.mktmpdir }
+    use_fake_home_dir { tmpdir }
+
+    before do
+      stub(context).targets_info do
+        {
+          "https://api.some-domain.com" => { :token => "bearer token1" },
+          "https://api.some-other-domain.com" => { :token => "bearer token2" }
+        }
+      end
+    end
+
+    after { FileUtils.rm_rf tmpdir }
+
+    describe "#save_target_info" do
+      it "adds the given target info, and writes the result to ~/.vmc/tokens.yml" do
+        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" }
+        }
+      end
+    end
+
+    describe "#remove_target_info" do
+      it "removes the given target, and writes the result to ~/.vmc/tokens.yml" do
+        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" }
+        }
+      end
+    end
+  end
+
+  describe "#client" do
+    use_fake_home_dir { "#{SPEC_ROOT}/fixtures/fake_home_dirs/new" }
+    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(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(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(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
+end
+