static 1.0.0 → 1.0.1

data/vendor/vmc-0.5.0/spec/vmc/cli/start/target_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require "webmock/rspec"
+
+command VMC::Start::Target do
+  let(:client) { fake_client :apps => [app] }
+  let(:app) { fake :app }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:target] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Set or display the target cloud, organization, and space" }
+      specify { 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(["-s"]) { should eq :space }
+    end
+
+    describe 'arguments' do
+      subject(:arguments) { command.arguments }
+      it 'have the correct commands' do
+        expect(arguments).to eq [{:type => :optional, :value => nil, :name => :url}]
+      end
+    end
+  end
+
+  describe 'running the command' do
+    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' }
+      let(:organizations) {
+        [ fake(:organization, :name => 'My Org', :guid => 'organization-id-1', :users => [user], :spaces => spaces),
+          fake(:organization, :name => 'My Org 2', :guid => 'organization-id-2') ]
+      }
+      let(:spaces) {
+        [ fake(:space, :name => 'Development', :guid => 'space-id-1'),
+          fake(:space, :name => 'Staging',     :guid => 'space-id-2') ]
+      }
+
+      let(:user) { stub! }
+      let(:organization) { organizations.first }
+      let(:client) do
+        fake_client :frameworks => fake_list(:framework, 3),
+          :organizations => organizations,
+          :token => CFoundry::AuthToken.new("bearer some-access-token")
+      end
+
+      before do
+        write_token_file({:space => "space-id-1", :organization => "organization-id-1"})
+        stub(client).current_user { user }
+        stub(client).organization { organization }
+        stub(client).current_organization { organization }
+        any_instance_of(described_class) do |instance|
+          stub(instance).client { client }
+        end
+      end
+
+      describe "switching the target" do
+        let(:target) { "some-valid-target.com" }
+        subject { vmc ["target", target] }
+
+        context "when the target is not valid" do
+          before { WebMock.stub_request(:get, "http://#{target}/info").to_return(:body => "{}") }
+
+          it "should still be able to switch to a valid target after that" 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) { 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 %W[target -s #{space.name}]
+        end
+
+        it "should not reprompt for organization" do
+          dont_allow_ask("Organization", anything)
+          run_command
+        end
+
+        it "sets the space param in the token file" do
+          run_command
+          expect(tokens_yaml["https://api.some-domain.com"][:space]).to be == 'space-id-2'
+        end
+      end
+    end
+  end
+end

data/vendor/vmc-0.5.0/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/vendor/vmc-0.5.0/spec/vmc/cli/user/delete_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require "vmc/cli/user/delete"
+
+describe VMC::User::Delete do
+  let(:global) { { :color => false, :quiet => true } }
+  let(:inputs) { { :email => "user@example.com"} }
+  let(:given) { {} }
+  let(:client) { fake_client }
+  let(:app) {}
+
+  before do
+    any_instance_of(VMC::CLI) do |cli|
+      stub(cli).client { client }
+    end
+  end
+
+  subject { Mothership.new.invoke(:delete_user, inputs, given, global) }
+
+  describe 'metadata' do
+    let(:command) { Mothership.commands[:delete_user] }
+
+    describe 'command' do
+      subject { command }
+      its(:description) { should eq "Delete a user" }
+      it { expect(Mothership::Help.group(:admin, :user)).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 => :normal, :value => nil, :name => :email }
+        ])
+      end
+    end
+  end
+
+  describe "deleting a user" do
+    context "when targeting a V2 API" do
+      before do
+        stub(client).version { 2 }
+      end
+
+      it_behaves_like "an error that gets passed through",
+        :with_exception => VMC::UserError,
+        :with_message => "Not implemented for v2."
+    end
+  end
+end

data/vendor/vmc-0.5.0/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!.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/vendor/vmc-0.5.0/spec/vmc/cli/user/register_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+command 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
+      stub(client).register
+      stub(client).base.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(error_output).to say("Passwords do not match.")
+      end
+
+      it "doesn't print out the score" do
+        subject
+        expect(output).to_not say("strength")
+      end
+
+      it "doesn't log in or register" do
+        dont_allow(client).register
+        dont_allow_invoke
+        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(error_output).to_not say("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(error_output).to say("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
+        dont_allow_invoke :login
+        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