trucker-cli 0.0.1

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

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+module CF
+  module Start
+    describe Target do
+      before do
+        stub_client_and_precondition
+      end
+
+      let(:client) { build(:client).tap {|client| client.stub(:apps => [app]) } }
+      let(:app) { build(: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(:user) { build(:user).tap{ |u| u.stub(:email => "user@example.com") } }
+          let(:organization) { build(:organization, :name => "My Org", :guid => "organization-id-1", :users => [user], :spaces => [space]) }
+          let(:space) { build(:space, :name => "Staging", :guid => "space-id-2", :developers => [user]) }
+
+          before do
+            client.stub(:logged_in?) { true }
+            client.stub(:organizations) { [organization] }
+            client.stub(:current_user) { user }
+            client.stub(:organization) { organization }
+            client.stub(:current_organization) { organization }
+            described_class.any_instance.stub(:client) { client }
+          end
+
+          describe "switching the target" do
+            let(:target) { "some-valid-target.com" }
+            subject { cf ["target", target] }
+
+            context "when the target is not valid" do
+              before { WebMock.stub_request(:get, "https://#{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
+                CFoundry::V2::Client.any_instance.stub(:info) { raise CFoundry::TargetRefused, "foo" }
+
+                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
+                CFoundry::V2::Client.any_instance.stub(:info) { raise CFoundry::InvalidTarget.new(target) }
+
+                subject
+                expect(error_output).to say("Invalid target URI.")
+              end
+            end
+          end
+
+          describe "switching the space" do
+            def run_command
+              cf %W[target -s #{space.name}]
+            end
+
+            it "calls use a PopulateTarget to ensure that an organization and space is set" do
+              CF::Populators::Target.should_receive(:new) { double(:target, :populate_and_save! => true) }
+              run_command
+            end
+
+            it "prints out the space from the updated client" do
+              CF::Populators::Target.any_instance.stub(:populate_and_save!) { true }
+              client.stub(:current_space) { space }
+
+              run_command
+              expect(output).to say("space: #{space.name}")
+            end
+          end
+
+          describe "displaying the target (no args)" do
+            it "prints things nicely" do
+              client.stub(:current_space) { space }
+              cf %W{target}
+              expect(output).to say(<<-STR)
+Target Information (where will apps be pushed):
+  CF instance: #{client.target} (API version: 2)
+  user: #{user.email}
+  target app space: #{space.name} (org: #{organization.name})
+              STR
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+module CF
+  module User
+    describe Create do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:create_user] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Create 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 => :optional, :value => nil, :name => :email}
+            ])
+          end
+        end
+      end
+
+      describe "running the command" do
+        let(:client) { build(:client) }
+        let(:org) { build(:organization) }
+        let(:user) { build(:user) }
+
+        before do
+          stub_client
+          client.stub(:register)
+        end
+
+        subject { cf %W[create-user --#{bool_flag(:force)}] }
+
+        context "when the user is not logged in" do
+          let(:force) { true }
+
+          before do
+            client.stub(: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 }
+          let(:confirmation) { "password1" }
+
+          before do
+            client.stub(:logged_in?) { true }
+            stub_ask("Email") { "some-angry-dude@example.com" }
+            stub_ask("Password", anything) { "password1" }
+            stub_ask("Verify Password", anything) { confirmation }
+
+            CF::Populators::Organization.stub(:new) { double(:organization, :populate_and_save! => org) }
+            client.stub(:register).with("some-angry-dude@example.com", "password1") { user }
+            user.stub(:update!)
+          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
+            it "creates a user" do
+              client.should_receive(:register).with("some-angry-dude@example.com", "password1") { user }
+              user.stub(:update!)
+              subject
+            end
+
+            it "adds the user to the current org" do
+              client.stub(:register).and_return(user)
+              user.should_receive(:update!)
+
+              subject
+
+              user.organizations.should == [org]
+              user.managed_organizations.should == [org]
+              user.audited_organizations.should == [org]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cf/cli/user/help_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module CF
+  module User
+    describe "Help"  do
+      let(:global) { {} }
+      let(:given) { {} }
+
+      subject do
+        capture_output { Mothership.new.invoke(:help, :command => "users") }
+      end
+
+      it "describes the command" do
+        subject
+        stdout.rewind
+        expect(stdout.readlines.first).to match /List all users/
+      end
+
+      context "when the user is not logged in" do
+        before do
+          capture_output { Mothership.new.invoke(:logout) }
+        end
+
+        it "does not require login" do
+          subject
+          stdout.rewind
+          expect(stdout.readlines.first).to_not match /Please log in first to proceed/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+module CF
+  module User
+    describe Passwd do
+      describe "metadata" do
+        let(:command) { Mothership.commands[:passwd] }
+
+        describe "command" do
+          subject { command }
+          its(:description) { should eq "Update the current user's password" }
+          it { expect(Mothership::Help.group(:admin, :user)).to include(subject) }
+        end
+
+        include_examples "inputs must have descriptions"
+      end
+
+      describe "#passwd" do
+        let(:client) { build(: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) { build(:user) }
+
+        before do
+          stub_client_and_precondition
+          client.stub(:logged_in?) { true }
+          client.stub(:current_user) { user }
+          client.stub(:register)
+          client.base.stub(:password_score).with(new_password).and_return(score)
+        end
+
+        subject { cf %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
+            user.should_not_receive(:change_password!)
+            subject
+          end
+        end
+
+        context "when the password is good or strong" do
+          before do
+            user.stub(: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
+            user.should_receive(:change_password!).with(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
+            user.should_not_receive(:change_password!)
+            subject
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+module CF
+  module User
+    describe Register do
+      let(:client) { build(:client) }
+
+      before do
+        stub_client_and_precondition
+      end
+
+      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(:email) { "a@b.com" }
+        let(:password) { "password" }
+        let(:verify_password) { password }
+        let(:force) { false }
+        let(:login) { false }
+        let(:score) { :strong }
+
+        before do
+          client.stub(:register)
+          client.base.stub(:password_score) { score }
+        end
+
+        subject { cf %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
+            client.should_not_receive(:register)
+            dont_allow_invoke
+            subject
+          end
+
+          context "and the force flag is passed" do
+            let(:force) { true }
+
+            it "doesn't verify the password" do
+              client.should_receive(:register).with(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
+            client.should_receive(:register).with(email, password)
+            subject
+          end
+
+          context "and the login flag is true" do
+            let(:login) { true }
+
+            it "logs in" do
+              described_class.any_instance.should_receive(:invoke).with(:login, :username => email, :password => password)
+              subject
+            end
+          end
+
+          context "and the login flag is false" do
+            it "doesn't log in" do
+              described_class.any_instance.should_not_receive(:invoke)
+              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
+            client.should_not_receive(:register).with(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 { cf %W[register --no-force --no-login] }
+
+          it "asks for the email, password and confirm password" do
+            should_ask("Email") { email }
+            should_ask("Password", anything) { password }
+            should_ask("Confirm Password", anything) { verify_password }
+            subject
+          end
+        end
+      end
+    end
+  end
+end