rhc 1.2.7 → 1.3.8

data/spec/rhc/auth_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+require 'rhc/commands'
+
+describe RHC::Auth::Basic do
+  let(:user){ 'test_user' }
+  let(:password){ 'test pass' }
+  let(:auth_hash){ {:user => user, :password => password} }
+  let(:options){ (o = Commander::Command::Options.new).default(default_options); o }
+  let(:default_options){ {} }
+
+  its(:username){ should be_nil }
+  its(:username?){ should be_false }
+  its(:password){ should be_nil }
+  its(:options){ should be_nil }
+  its(:openshift_server){ should == 'openshift.redhat.com' }
+
+  context "with user options" do
+    subject{ described_class.new(options) }
+
+    its(:username){ should be_nil }
+    its(:username?){ should be_false }
+    its(:password){ should be_nil }
+    its(:options){ should equal(options) }
+
+    context "that include user info" do
+      let(:default_options){ {:rhlogin => user, :password => password} }
+
+      its(:username){ should == user }
+      its(:username?){ should be_true }
+      its(:password){ should == password }
+    end
+
+    context "that includes server" do
+      let(:default_options){ {:server => 'test.com'} }
+
+      its(:openshift_server){ should == 'test.com' }
+      it do
+        subject.should_receive(:ask).with("Login to test.com: ").and_return(user)
+        subject.send(:ask_username).should == user
+      end
+    end
+
+    context "with --noprompt" do
+      let(:default_options){ {:noprompt => true} }
+
+      its(:ask_username){ should be_false }
+      its(:ask_password){ should be_false }
+      its(:username?){ should be_false }
+      it("should not retry") do 
+        subject.should_not_receive(:ask_username)
+        subject.retry_auth?(mock(:status => 401)).should be_false
+      end
+    end
+  end
+
+  context "when initialized with a hash" do
+    subject{ described_class.new({:rhlogin => user, :password => password}) }
+    its(:username){ should == user }
+    its(:password){ should == password }
+  end
+
+
+  describe "#ask_username" do
+    before{ subject.should_receive(:openshift_server).and_return('test.com') }
+    before{ subject.should_receive(:ask).with("Login to test.com: ").and_return(user) }
+
+    it do
+      subject.send(:ask_username).should == user
+      subject.send(:username).should == user
+    end
+
+    context "with a different user" do
+      subject{ described_class.new('other', nil) }
+      it do
+        subject.send(:ask_username).should == user
+        subject.send(:username).should == user
+      end
+    end
+  end
+
+  describe "#ask_password" do
+    before{ subject.should_receive(:ask).with("Password: ").and_return(password) }
+    it do
+      subject.send(:ask_password).should == password
+      subject.send(:password).should == password
+    end
+
+    context "with a different password" do
+      subject{ described_class.new(user, 'other') }
+      it do
+        subject.send(:ask_password).should == password
+        subject.send(:password).should == password
+      end
+    end
+  end
+
+  describe "#to_request" do
+    let(:request){ {} }
+
+    context "when the request is lazy" do
+      let(:request){ {:lazy_auth => true} }
+      before{ subject.should_receive(:ask_username).never }
+      before{ subject.should_receive(:ask_password).never }
+
+      it { subject.to_request(request).should == request }
+    end
+
+    context "when password and user are provided" do
+      subject{ described_class.new(user, password) }
+
+      it { subject.to_request(request).should equal(request) }
+      it { subject.to_request(request).should == auth_hash }
+
+      context "it should remember cookies" do
+        let(:response){ mock(:cookies => [mock(:name => 'rh_sso', :value => '1')], :status => 200) }
+        it{ subject.retry_auth?(response); subject.to_request(request)[:cookies].should == {:rh_sso => '1'} }
+      end
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+
+    context "when password is not provided" do
+      subject{ described_class.new(user, nil) }
+
+      its(:password){ should be_nil }
+      it "should ask for the password" do
+        subject.should_receive(:ask_password).and_return(password)
+        subject.to_request(request).should == auth_hash
+      end
+      it "should remember the password" do
+        subject.should_receive(:ask_password).and_return(password)
+        subject.to_request(request)
+        subject.to_request(request).should == auth_hash
+      end
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+        before{ subject.should_receive(:ask_password).never }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+
+    context "when user is not provided" do
+      subject{ described_class.new(nil, password) }
+
+      its(:username){ should be_nil }
+      it "should ask for the username" do
+        subject.should_receive(:ask_username).and_return(user)
+        subject.to_request(request).should == auth_hash
+      end
+      it "should remember the username" do
+        subject.should_receive(:ask_username).and_return(user)
+        subject.to_request(request)
+        subject.to_request(request).should == auth_hash
+      end
+
+      context "when the request is lazy" do
+        let(:request){ {:lazy_auth => true} }
+        before{ subject.should_receive(:ask_username).never }
+
+        it { subject.to_request(request).should == auth_hash.merge(request) }
+      end
+    end
+  end
+
+  describe "#retry_auth?" do
+    context "when the response succeeds" do
+      let(:response){ mock(:cookies => {}, :status => 200) }
+
+      it{ subject.retry_auth?(response).should be_false }
+      after{ subject.cookie.should be_nil }
+    end
+    context "when the response succeeds with a cookie" do
+      let(:response){ mock(:cookies => [mock(:name => 'rh_sso', :value => '1')], :status => 200) }
+      it{ subject.retry_auth?(response).should be_false }
+      after{ subject.cookie.should == '1' }
+    end
+    context "when the response requires authentication" do
+      let(:response){ mock(:status => 401) }
+      after{ subject.cookie.should be_nil }
+
+      context "with no user and no password" do
+        subject{ described_class.new(nil, nil) }
+        it("should ask for user and password") do
+          subject.should_receive(:ask_username).and_return(user)
+          subject.should_receive(:ask_password).and_return(password)
+          subject.retry_auth?(response).should be_true
+        end
+      end
+
+      context "with user and no password" do
+        subject{ described_class.new(user, nil) }
+        it("should ask for password only") do
+          subject.should_receive(:ask_password).and_return(password)
+          subject.retry_auth?(response).should be_true
+        end
+        it("should ask for password twice") do
+          subject.should_receive(:ask_password).twice.and_return(password)
+          subject.retry_auth?(response).should be_true
+          subject.retry_auth?(response).should be_true
+        end
+      end
+
+      context "with user and password" do
+        subject{ described_class.new(user, password) }
+        it("should not prompt for reauthentication") do
+          subject.should_not_receive(:ask_password)
+          subject.should_receive(:error).with("Username or password is not correct")
+          subject.retry_auth?(response).should be_false
+        end
+
+        it "should forget a saved cookie" do
+          subject.instance_variable_set(:@cookie, '1')
+          subject.should_not_receive(:ask_password)
+          subject.should_receive(:error).with("Username or password is not correct")
+          subject.retry_auth?(response).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/rhc/cli_spec.rb

@@ -2,6 +2,15 @@ require 'spec_helper'
 
 describe RHC::CLI do
 
+  shared_examples_for 'a global help page' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain the program description') { run_output.should =~ /Command line interface for OpenShift/ }
+    it('should describe getting started') { run_output.should =~ /Getting started:/ }
+    it('should describe basic command') { run_output.should =~ /Working with apps:/ }
+    it('should mention the help command') { run_output.should =~ /See 'rhc help <command>'/ }
+    it('should mention the help options command') { run_output.should =~ /rhc help options/ }
+  end
+
   shared_examples_for 'a help page' do
     let(:arguments) { @arguments or raise "no arguments" }
     it('should contain the program description') { run_output.should =~ /Command line interface for OpenShift/ }
@@ -9,20 +18,30 @@ describe RHC::CLI do
     it('should provide a --config switch') { run_output.should =~ /\-\-config FILE/ }
   end
 
+  shared_examples_for 'a command-line options help page' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain an introduction') { run_output.should =~ /The following options can be passed to any/ }
+    it('should reference the configuration') { run_output.should match(".openshift/express.conf") }
+    it('should describe the --config switch') { run_output.should =~ /\-\-config FILE/ }
+    it('should describe the --ssl-version switch') { run_output.should =~ /\-\-ssl\-version VERSION/ }
+  end
+
   shared_examples_for 'an invalid command' do
     let(:arguments) { @arguments }
     it('should contain the invalid command message') { run_output.should =~ /is not recognized/ }
     it('should contain the arguments') { run_output.should include(@arguments[0]) }
     it('should reference --help') { run_output.should =~ / help\b/ }
   end
-  
+
   shared_examples_for 'version output' do
     let(:arguments) { @arguments }
     it 'should contain version output' do
       run_output.should =~ /rhc \d+\.\d+(:?\.d+)?/
     end
   end
-  
+
+  before{ base_config }
+
   describe "--version" do
     context "by itself" do
       before :each do
@@ -30,19 +49,17 @@ describe RHC::CLI do
       end
       it_should_behave_like 'version output'
     end
-    
-    context 'given as "-v"' do
-      before :each do
-        @arguments = ['-v']
-      end
-      it_should_behave_like 'version output'
-    end
   end
 
   describe '#start' do
     context 'with no arguments' do
       before(:each) { @arguments = [] }
-      it_should_behave_like 'a help page'
+      it_should_behave_like 'a global help page'
+    end
+
+    context 'with an ambiguous option' do
+      let(:arguments){ ['help', '-s'] }
+      it('should describe an ambiguous error'){ run_output.should match("The option -s is ambiguous. You will need to specify the entire option.") }
     end
 
     context 'with an invalid command' do
@@ -62,27 +79,37 @@ describe RHC::CLI do
 
     context 'with --help' do
       before(:each){ @arguments = ['--help'] }
-      it_should_behave_like 'a help page'
+      it_should_behave_like 'a global help page'
     end
 
     context 'with -h' do
       before(:each){ @arguments = ['-h'] }
-      it_should_behave_like 'a help page'
+      it_should_behave_like 'a global help page'
     end
 
     context 'with help' do
       before(:each){ @arguments = ['help'] }
-      it_should_behave_like 'a help page'
+      it_should_behave_like 'a global help page'
+    end
+
+    context 'with help options' do
+      before(:each){ @arguments = ['help', 'options'] }
+      it_should_behave_like 'a command-line options help page'
     end
   end
 
   describe '#set_terminal' do
     before(:each) { mock_terminal }
     it('should update $terminal.wrap_at') do 
-      $stdin.should_receive(:tty?).and_return(true)
+      $stdin.should_receive(:tty?).twice.and_return(true)
       HighLine::SystemExtensions.should_receive(:terminal_size).and_return([5])
       expect { RHC::CLI.set_terminal }.to change($terminal, :wrap_at)
     end
+    it('should update $terminal.page_at') do 
+      $stdin.should_receive(:tty?).twice.and_return(true)
+      $stdout.should_receive(:tty?).twice.and_return(true)
+      expect { RHC::CLI.set_terminal }.to change($terminal, :page_at)
+    end
   end
 
 end

data/spec/rhc/command_spec.rb

@@ -3,6 +3,9 @@ require 'rhc/commands/base'
 require 'rhc/exceptions'
 
 describe RHC::Commands::Base do
+
+  before{ base_config }
+
   describe '#object_name' do
     subject { described_class }
     its(:object_name) { should == 'base' }
@@ -45,7 +48,6 @@ describe RHC::Commands::Base do
       it("should have an object name") { subject.object_name.should == 'test' }
       it("should run with wizard") do
         FakeFS do
-          RHC::Config.set_defaults
           wizard_run = false
           RHC::Wizard.stub!(:new) do |config|
             RHC::Wizard.unstub!(:new)
@@ -80,6 +82,22 @@ describe RHC::Commands::Base do
       it("invokes the right method") { expects_running('static').should call(:run).on(instance).with(no_args) }
     end
 
+    context 'when a command calls exit' do
+      subject do 
+        Kernel.module_eval do 
+          class Failing < RHC::Commands::Base
+            def run
+              exit 2
+            end
+          end
+        end
+        Failing
+      end
+
+      it("invokes the right method") { expects_running('failing').should call(:run).on(instance).with(no_args) }
+      it{ expects_running('failing').should exit_with_code(2) }
+    end
+
     context 'when statically defined with no default method' do
       subject do
         Kernel.module_eval do
@@ -93,7 +111,7 @@ describe RHC::Commands::Base do
             alias_action :exe, :deprecated => true
             def execute(testarg); 1; end
 
-            argument :args, "Test arg list", [], :arg_type => :list
+            argument :args, "Test arg list", ['--tests'], :arg_type => :list
             summary "Test command execute-list"
             def execute_list(args); 1; end
 
@@ -125,6 +143,10 @@ describe RHC::Commands::Base do
         it { expects_running('statis', 'execute', 'duparg', '--testarg', 'duparg2').should exit_with_code(1) }
       end
 
+      context 'and when the provided option is ambiguous' do
+        it { expects_running('static', 'execute', '-t', '--trace').should raise_error(OptionParser::AmbiguousOption) }
+      end
+
       context 'and when execute is called with too many arguments' do
         it { expects_running('static', 'execute', 'arg1', 'arg2').should exit_with_code(1) }
       end
@@ -136,6 +158,8 @@ describe RHC::Commands::Base do
       context 'and when execute_list is called' do
         it { expects_running('static', 'execute-list', '--trace').should call(:execute_list).on(instance).with([]) }
         it { expects_running('static', 'execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
+        it { expects_running('static', 'execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
+        it('should make the option available') { command_for('static', 'execute-list', '1', '2', '3').send(:options).tests.should == ['1','2','3'] }
       end
 
       context 'and when an error is raised in a call' do
@@ -166,20 +190,25 @@ describe RHC::Commands::Base do
   end
 
   describe "rest_client" do
-    before do
-      mock_terminal
-      RHC::Rest::Client.stub!(:new) { |openshift_rest_node, username, password, debug| @username = username; @password = password; true}
-    end
+    let(:auth){ mock }
+    before{ RHC::Auth::Basic.should_receive(:new).once.with(subject.send(:options)).and_return(auth) }
 
-    it "should ask for username" do
-      FakeFS do
-        $terminal.write_line("testuser@foo.bar")
-        $terminal.write_line("password")
-        subject.send(:rest_client).should be_true
-        @username.should == "testuser@foo.bar"
-        subject.send(:config)["default_rhlogin"].should == @username
-        @password.should == "password"
-      end
+    it do
+      subject.should_receive(:client_from_options).with(:auth => auth)
+      subject.send(:rest_client)
     end
+    it { subject.send(:rest_client).should be_a(RHC::Rest::Client) }
+    it { subject.send(:rest_client).should equal subject.send(:rest_client) }
   end
 end
+
+describe Commander::Command::Options do
+  it{ subject.foo = 'bar'; subject.foo.should == 'bar' }
+  it{ subject.foo = lambda{ 'bar' }; subject.foo.should == 'bar' }
+  it{ subject.foo = lambda{ 'bar' }; subject[:foo].should == 'bar' }
+  it{ subject.foo = lambda{ 'bar' }; subject['foo'].should == 'bar' }
+  it{ subject.foo = lambda{ 'bar' }; subject.__hash__[:foo].should be_a Proc }
+  it{ subject[:foo] = lambda{ 'bar' }; subject.foo.should == 'bar' }
+  it{ subject['foo'] = lambda{ 'bar' }; subject.foo.should == 'bar' }
+  it{ Commander::Command::Options.new(:foo => 1).foo.should == 1 }
+end

data/spec/rhc/commands/account_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'rhc'
+require 'rhc/commands/account'
+
+describe RHC::Commands::Account do
+
+  describe 'run' do
+    let(:arguments) { ['account'] }
+    let(:username) { 'foo' }
+    let(:password) { 'pass' }
+    let(:server) { mock_uri }
+    before{ user_config }
+    before do
+      stub_api(true)
+      stub_user
+    end
+
+    it('should display the correct user') { run_output.should =~ /Login:\s*#{username}/ }
+    it('should not show') { run_output.should_not =~ /Plan:/ }
+    it('should show the gear capabilities') { run_output.should =~ /Allowed Gear Sizes:\s*small/ }
+    it('should show the consumed gears') { run_output.should =~ /Gears Used:\s*0/ }
+    it('should show the maximum gears') { run_output.should =~ /Gears Allowed:\s*3/ }
+    it { expect { run }.should exit_with_code(0) }
+
+    context 'with a freeshift plan' do
+      let(:user_plan_id){ 'freeshift' }
+      it('should show') { run_output.should =~ /Plan:\s*FreeShift/ }
+    end
+
+    context 'with a megashift plan' do
+      let(:user_plan_id){ 'megashift' }
+      it('should show') { run_output.should =~ /Plan:\s*MegaShift/ }
+    end
+
+    context 'with a arbitrary plan' do
+      let(:user_plan_id){ 'other' }
+      it('should show') { run_output.should =~ /Plan:\s*Other/ }
+    end
+  end
+end