rhc 1.4.8 → 1.5.13

data/spec/rhc/helpers_spec.rb

@@ -25,7 +25,7 @@ describe RHC::Helpers do
         @config ||= RHC::Config.new
       end
       def options
-        @options ||= OpenStruct.new([:server])
+        @options ||= OpenStruct.new(:server => nil)
       end
     end.new
   end
@@ -45,14 +45,34 @@ describe RHC::Helpers do
 
   it("should decode json"){ subject.decode_json("{\"a\" : 1}").should == {'a' => 1} }
 
-  it("should output green on success") do
-    capture{ subject.success 'this is green' }.should == "\e[32mthis is green\e[0m\n"
+  shared_examples_for "colorized output" do
+    it("should be colorized") do
+      message = "this is #{_color}"
+      output = capture{ subject.send(method,message) }
+      output.should be_colorized(message,_color)
+    end
+    it("should return true"){ subject.send(method,'anything').should be_true }
+  end
+
+  context "success output" do
+    let(:_color){ :green }
+    let(:method){ :success }
+    it_should_behave_like "colorized output"
+  end
+
+  context "warn output" do
+    let(:_color){ :yellow }
+    let(:method){ :warn }
+    it_should_behave_like "colorized output"
   end
-  it("should output yellow on warn") do
-    capture{ subject.success 'this is yellow' }.should == "\e[32mthis is yellow\e[0m\n"
+
+  context "info output" do
+    let(:_color){ :cyan }
+    let(:method){ :info }
+    it_should_behave_like "colorized output"
   end
-  it("should return true on success"){ subject.success('anything').should be_true }
-  it("should return true on success"){ subject.warn('anything').should be_true }
+
+  it("should invoke debug from debug_error"){ expect{ subject.debug_error(mock(:class => "Mock", :message => 'msg', :backtrace => [])) }.to call(:debug).on(subject).with("msg (Mock)\n  ") }
 
   it("should draw a table") do
     subject.table([[10,2], [3,40]]) do |i|
@@ -60,7 +80,13 @@ describe RHC::Helpers do
     end.should == ['10 2','3  40']
   end
 
-  it("should output a table") do 
+  context "error output" do
+    let(:_color){ :red }
+    let(:method){ :error }
+    it_should_behave_like "colorized output"
+  end
+
+  it("should output a table") do
     subject.send(:display_no_info, 'test').should == ['This test has no information to show']
   end
 
@@ -71,6 +97,18 @@ describe RHC::Helpers do
     d.year.should == 2012
   end
 
+  describe "#distance_of_time_in_words" do
+    it{ subject.distance_of_time_in_words(0, 1).should == 'less than 1 minute' }
+    it{ subject.distance_of_time_in_words(0, 60).should == '1 minute' }
+    it{ subject.distance_of_time_in_words(0, 130).should == '2 minutes' }
+    it{ subject.distance_of_time_in_words(0, 50*60).should == 'about 1 hour' }
+    it{ subject.distance_of_time_in_words(0, 3*60*60).should == 'about 3 hours' }
+    it{ subject.distance_of_time_in_words(0, 25*60*60).should == 'about 1 day' }
+    it{ subject.distance_of_time_in_words(0, 3*24*60*60).should == '3 days' }
+    it{ subject.distance_of_time_in_words(0, 40*24*60*60).should == 'about 1 month' }
+    it{ subject.distance_of_time_in_words(0, 10*30*24*60*60).should == 'about 10 months' }
+  end
+
   context 'using the current time' do
     let(:date){ Time.local(2008,1,2,1,1,0) }
     let(:today){ Date.new(2008,1,2) }
@@ -200,6 +238,14 @@ describe RHC::Helpers do
     it{ run_output.should match("The certificate 'not_a_file' cannot be loaded: No such file or directory ") }
   end
 
+  describe "#get_properties" do
+    it{ tests.send(:get_properties, stub(:plan_id => 'freeshift'), :plan_id).should == [[:plan_id, 'FreeShift']] }
+    context "when an error is raised" do
+      subject{ stub.tap{ |s| s.should_receive(:foo).and_raise(::Exception) } }
+      it{ tests.send(:get_properties, subject, :foo).should == [[:foo, '<error>']] }
+    end
+  end
+
   context "Formatter" do
     before{ tests.reset }
 
@@ -320,8 +366,14 @@ describe RHC::Helpers do
       subject.should_receive(:error).with('An error')
       subject.fingerprint_for_local_key('1').should be_nil
     end
+
+    it "should catch exceptions from fingerprint failures" do
+      Net::SSH::KeyFactory.should_receive(:load_public_key).with('1').and_raise(StandardError.new("An error"))
+      subject.should_receive(:error).with('An error')
+      subject.fingerprint_for_local_key('1').should be_nil
+    end
   end
-  
+
   context "Resolv helper" do
     let(:resolver) { Object.new }
     let(:existent_host) { 'real_host' }
@@ -353,6 +405,7 @@ describe RHC::Helpers do
   class OutputTests
     include RHC::Helpers
     include RHC::SSHHelpers
+    include RHC::OutputHelpers
 
     def initialize
       @print_num = 0

data/spec/rhc/rest_application_spec.rb

@@ -28,6 +28,30 @@ module RHC
         end
       end
 
+      describe "#ssh_string" do
+        context "with valid url" do
+          subject{ described_class.new('ssh_url' => "ssh://foo@bar.com/path") }
+          its(:ssh_string){ should == "foo@bar.com" }
+        end
+        context "with bad url" do
+          subject{ described_class.new('ssh_url' => "ssh://") }
+          its(:ssh_string){ should == "ssh://" }
+        end
+      end
+
+      describe "#host" do
+        context "with bad url" do
+          subject{ described_class.new('app_url' => "http://") }
+          its(:app_url){ should == "http://" }
+          its(:host){ should be_nil }
+        end
+        context "with http url" do
+          subject{ described_class.new('app_url' => "http://bar.com/path") }
+          its(:app_url){ should == "http://bar.com/path" }
+          its(:host){ should == "bar.com" }
+        end
+      end
+
       context "#add_cartridge" do
         before do
           stub_api_request(:any, app_links['ADD_CARTRIDGE']['relative']).

data/spec/rhc/rest_client_spec.rb

@@ -212,69 +212,52 @@ module RHC
             match.class.should == RHC::Rest::Domain
           end
           it "raise an error when no matching domain IDs can be found" do
-            expect { client.find_domain('mock_domain_2') }.should raise_error(RHC::DomainNotFoundException)
+            expect { client.find_domain('mock_domain_2') }.should raise_error(RHC::Rest::DomainNotFoundException)
           end
         end
 
-        context "#find_application" do
+        context "find_application" do
+          let(:mock_domain){ 'mock_domain_0' }
+          let(:mock_app){ 'mock_app' }
+          let(:missing){ 'no_match' }
           before(:each) do
-            stub_api_request(:any, client_links['LIST_DOMAINS']['relative']).
-              to_return({ :body   => {
-                            :type => 'domains',
-                            :data =>
-                            [{ :id    => 'mock_domain_0',
-                               :links => mock_response_links(mock_domain_links('mock_domain_0')),
-                             },
-                             { :id    => 'mock_domain_1',
-                               :links => mock_response_links(mock_domain_links('mock_domain_1')),
-                             }]
-                          }.to_json,
-                          :status => 200
-                        })
-            stub_api_request(:any, domain_0_links['LIST_APPLICATIONS']['relative']).
-              to_return({ :body   => {
-                            :type => 'applications',
-                            :data =>
-                            [{ :domain_id       => 'mock_domain_0',
-                               :name            => 'mock_app',
-                               :creation_time   => Time.new.to_s,
-                               :uuid            => 1234,
-                               :aliases         => ['alias_1', 'alias_2'],
-                               :server_identity => 'mock_server_identity',
-                               :links           => mock_response_links(mock_app_links('mock_domain_0','mock_app')),
-                             }]
-                          }.to_json,
-                          :status => 200
-                        })
-            stub_api_request(:any, domain_1_links['LIST_APPLICATIONS']['relative']).
-              to_return({ :body   => {
-                            :type => 'applications',
-                            :data =>
-                            [{ :domain_id       => 'mock_domain_1',
-                               :name            => 'mock_app',
-                               :creation_time   => Time.new.to_s,
-                               :uuid            => 1234,
-                               :aliases         => ['alias_1', 'alias_2'],
-                               :server_identity => 'mock_server_identity',
-                               :links           => mock_response_links(mock_app_links('mock_domain_1','mock_app')),
-                             }]
-                          }.to_json,
-                          :status => 200
-                        })
-          end
-          it "returns application objects for matching application IDs" do
-            domain = client.domains[0]
-            domain.applications.each do |app|
-              match = domain.find_application(app.name)
+            stub_one_application(mock_domain, mock_app)
+            stub_one_application(mock_domain, missing, {
+              :type => nil,
+              :data => nil,
+              :messages => [{
+                :exit_code => 101,
+                :field => nil,
+                :severity => 'error',
+                :text => "Application #{missing} not found"
+              }],
+              :status => 'not_found'
+            }, 404)
+            stub_one_application(missing, mock_app, {
+              :type => nil,
+              :data => nil,
+              :messages => [{
+                :exit_code => 127,
+                :field => nil,
+                :severity => 'error',
+                :text => "Domain #{missing} not found"
+              }],
+              :status => 'not_found'
+            }, 404)
+          end
+          it "returns application object for nested application IDs" do
+              match = client.find_application(mock_domain, mock_app)
               match.class.should     == RHC::Rest::Application
-              match.name.should      == 'mock_app'
-              match.domain_id.should == "#{domain.id}"
+              match.name.should      == mock_app
+              match.domain_id.should == mock_domain
               match.send(:links).should     ==
-                mock_response_links(mock_app_links("#{domain.id}",'mock_app'))
-            end
+                mock_response_links(mock_app_links(mock_domain, mock_app))
           end
-          it "Raises an excpetion when no matching applications can be found" do
-            expect { client.domains[0].find_application('no_match') }.should raise_error(RHC::ApplicationNotFoundException)
+          it "Raises an exception when no matching applications can be found" do
+            expect { client.find_application(mock_domain, missing) }.should raise_error(RHC::Rest::ApplicationNotFoundException)
+          end
+          it "Raises an exception when no matching domain can be found" do
+            expect { client.find_application(missing, mock_app) }.should raise_error(RHC::Rest::DomainNotFoundException)
           end
         end
 
@@ -581,6 +564,33 @@ module RHC
           end
         end
       end
+
+      describe "#supports_sessions?" do
+        before{ subject.should_receive(:api).at_least(2).times.and_return(stub) }
+        context "with ADD_AUTHORIZATION link" do
+          before{ subject.api.should_receive(:supports?).twice.with('ADD_AUTHORIZATION').and_return(true) }
+          its(:supports_sessions?){ should be_true }
+        end
+        context "without ADD_AUTHORIZATION link" do
+          before{ subject.api.should_receive(:supports?).twice.with('ADD_AUTHORIZATION').and_return(false) }
+          its(:supports_sessions?){ should be_false }
+        end
+      end
+
+      describe "#authorizations" do
+        before do
+          stub_api_request(:get, '').to_return({:body => {
+              :data => mock_response_links(mock_api_with_authorizations),
+              :supported_api_versions => [1.0, 1.1]
+            }.to_json,
+            :status => 200
+          })
+          stub_authorizations
+        end
+        it{ client.authorizations.first.token.should == 'a_token_value' }
+        it{ client.authorizations.first.note.should == 'an_authorization' }
+        it{ client.authorizations.first.expires_in_seconds.should == 60 }
+      end
     end
   end
 end

data/spec/rhc/rest_spec.rb

@@ -279,6 +279,15 @@ module RHC
       end
     end
 
+    describe "#new_request" do
+      it{ subject.send(:new_request, :api_version => 2.0).last[4]['accept'].should == 'application/json;version=2.0' }
+      it{ subject.send(:new_request, :headers => {:accept => :xml}, :api_version => 2.0).last[4]['accept'].should == 'application/xml;version=2.0' }
+      context "with the default api version" do
+        before{ subject.should_receive(:current_api_version).and_return('1.0') }
+        it{ subject.send(:new_request, {}).last[4]['accept'].should == 'application/json;version=1.0' }
+      end
+    end
+
     # request function
     describe "#request" do
       let(:response){ lambda { subject.request(request) } }
@@ -307,12 +316,12 @@ module RHC
             :status  => 200,
             :headers => { 'Set-Cookie' => "rh_sso=test_ssh_cookie" }
           }
-          stub_request(:get, mock_href).to_return(return_data)
+          stub_request(:get, mock_href).with{ |req| req.headers['Accept'].should == 'application/json;version=1.0' }.to_return(return_data)
         end
 
         it "sends the response to be deserialized" do
           dom_obj = RHC::Rest::Domain.new(object)
-          subject.request(request.merge(:payload => {}, :timeout => 300)).should have_same_attributes_as(dom_obj)
+          subject.request(request.merge(:payload => {}, :api_version => '1.0', :timeout => 300)).should have_same_attributes_as(dom_obj)
         end
       end
 

data/spec/rhc/wizard_spec.rb

@@ -22,13 +22,24 @@ describe RHC::Wizard do
   let(:default_options){ {} }
 
   describe "#finalize_stage" do
-    subject{ RHC::Wizard.new(config, options) }
+    subject{ described_class.new(config, options) }
     before{ subject.should_receive(:say).with(/The OpenShift client tools have been configured/) }
     it{ subject.send(:finalize_stage).should be_true }
   end
 
+  describe "#token_store" do
+    subject{ described_class.new(config, options) }
+    it{ subject.send(:token_store).should be_a(RHC::Auth::TokenStore) }
+  end
+
+  describe "#has_configuration?" do
+    subject{ described_class }
+    before{ File.should_receive(:exists?).with(RHC::Config.local_config_path).at_least(1).times.and_return(true) }
+    its(:has_configuration?){ should be_true }
+  end
+
   describe "#test_ssh_connectivity" do
-    subject{ RHC::Wizard.new(config, options) }
+    subject{ described_class.new(config, options) }
     let(:app) do
       app = Object.new
       app.should_receive(:host).at_least(1).and_return('foo.com')
@@ -66,30 +77,39 @@ describe RHC::Wizard do
     let(:rest_client){ stub }
     let(:auth){ subject.send(:auth) }
 
-    subject{ RHC::Wizard.new(config, options) }
+    subject{ described_class.new(config, options) }
 
-    def expect_client_test
+    def expect_client_test(with_sessions=false)
       subject.should_receive(:new_client_for_options).ordered.and_return(rest_client)
       rest_client.should_receive(:api).ordered
       rest_client.should_receive(:user).ordered.and_return(true)
+      rest_client.should_receive(:supports_sessions?).ordered.and_return(with_sessions)
     end
     def expect_raise_from_api(error)
-      #subject.send(:auth).should_receive(:ask).with("Using #{user} to login to openshift.redhat.com").and_return(username).ordered
-      #subject.send(:auth).should_receive(:ask).with("Password: ").and_return(password).ordered
       subject.should_receive(:new_client_for_options).ordered.and_return(rest_client)
       rest_client.should_receive(:api).ordered.and_raise(error)
     end
 
     it "should prompt for user and password" do
-      #auth.should_receive(:ask).with("Login to openshift.redhat.com: ").ordered.and_return(user)
-      #auth.should_receive(:ask).with("Password: ").ordered.and_return(password)
       expect_client_test
-
       subject.send(:login_stage).should be_true
     end
 
+    context "with token" do
+      let(:token){ 'a_test_value' }
+      let(:default_options){ {:token => token, :rhlogin => user} }
+      before{ subject.should_receive(:say).with(/Using an existing token for #{user} to login to /).ordered }
+
+      it "should continue without prompt" do
+        expect_client_test
+        subject.send(:login_stage).should be_true
+      end
+    end
+
     context "with credentials" do
-      let(:default_options){ {:rhlogin => user, :password => password} }
+      let(:server){ mock_uri }
+      let(:default_options){ {:rhlogin => user, :password => password, :server => server} }
+      before{ subject.should_receive(:say).with(/Using #{user} to login to /).ordered }
 
       it "should warn about a self signed cert error" do
         expect_raise_from_api(RHC::Rest::SelfSignedCertificate.new('reason', 'message'))
@@ -131,6 +151,36 @@ describe RHC::Wizard do
         subject.send(:login_stage).should be_nil
         options.insecure.should be_false
       end
+
+      context "with a server that supports tokens" do
+        before{ expect_client_test(true) }
+        let(:token){ 'a_test_value' }
+        let(:auth_token){ mock(:token => token, :expires_in_seconds => 100) }
+        let(:store){ mock }
+        before{ RHC::Auth::TokenStore.should_receive(:new).any_number_of_times.and_return(store) }
+
+        it "should not generate a token if the user does not request it" do
+          subject.should_receive(:info).with(/OpenShift can create and store a token on disk/).ordered
+          subject.should_receive(:agree).with(/Generate a token now?/).ordered.and_return(false)
+
+          subject.send(:login_stage).should be_true
+          options.token.should be_nil
+        end
+
+        it "should generate a token if the user requests it" do
+          subject.should_receive(:info).with(/OpenShift can create and store a token on disk/).ordered
+          subject.should_receive(:agree).with(/Generate a token now?/).ordered.and_return(true)
+          subject.should_receive(:say).with(/Generating an authorization token for this client /).ordered
+          rest_client.should_receive(:new_session).ordered.and_return(auth_token)
+          store.should_receive(:put).with(user, server, token).ordered.and_return(true)
+          subject.should_receive(:new_client_for_options).ordered.and_return(rest_client)
+          rest_client.should_receive(:user).ordered.and_return(true)
+          subject.should_receive(:success).with(/lasts 1 minute/).ordered
+
+          subject.send(:login_stage).should be_true
+          options.token.should == token
+        end
+      end
     end
   end
 
@@ -231,9 +281,8 @@ describe RHC::Wizard do
           should_be_done
         end
       end
-
       context "when the user inputs incorrect authentication" do
-        before{ stub_api_request(:get, 'broker/rest/user', :user => username, :password => 'invalid').to_return(:status => 401) }
+        before{ stub_api_request(:get, 'broker/rest/user', :user => username, :password => 'invalid').to_return(:status => 401).times(1).to_return(simple_user(username)) }
         it "should prompt them again" do
           should_greet_user
 

data/spec/spec_helper.rb

@@ -72,6 +72,86 @@ module Commander::UI
 end
 
 
+module CommandExampleHelpers
+  #
+  # Allow this example to stub command methods
+  # by guaranteeing the instance exists prior
+  # to command execution.  Use with methods on
+  # CommandHelpers
+  #
+  def using_command_instance
+    subject{ described_class }
+    let(:instance) { described_class.new }
+  end
+end
+#
+# Helper methods for executing commands and
+# stubbing/mocking methods
+#
+module CommandHelpers
+  def command_runner(*args)
+    mock_terminal
+    new_command_runner *args do
+      instance #ensure instance is created before subject :new is mocked
+      subject.should_receive(:new).any_number_of_times.and_return(instance)
+      RHC::Commands.to_commander
+    end
+  end
+  def run!(*args)
+    command_runner(*args).run!
+  end
+  def expects_running(*args, &block)
+    r = command_runner(*args)
+    lambda { r.run! }
+  end
+  def command_for(*args)
+    command = nil
+    RHC::Commands.stub(:execute){ |cmd, method, args| command = cmd; 0 }
+    command_runner(*args).run!
+    command
+  end
+
+  #
+  # These methods assume the example has declared
+  # let(:arguments){ [<arguments>] }
+  #
+
+  def run_command
+    mock_terminal
+    input.each { |i| $terminal.write_line(i) } if respond_to?(:input)
+    $terminal.close_write
+    run!(*arguments)
+  end
+  def command_output
+    run_command
+  rescue SystemExit => e
+    "#{@output.string}\n#{$stderr.string}#{e}"
+  else
+    "#{@output.string}\n#{$stderr.string}"
+  end
+
+  #
+  # These methods bypass normal command stubbing.
+  # Should really be used when stubbing the whole
+  # path.  Most specs should use run_instance.
+  #
+  def run(input=[])
+    mock_terminal
+    input.each { |i| $terminal.write_line(i) }
+    $terminal.close_write
+    RHC::CLI.start(arguments)
+  end
+
+  def run_output(input=[])
+    run(input)
+  rescue SystemExit => e
+    "#{@output.string}\n#{$stderr.string}#{e}"
+  else
+    "#{@output.string}\n#{$stderr.string}"
+  end
+
+end
+
 module ClassSpecHelpers
 
   include Commander::Delegates
@@ -108,31 +188,6 @@ module ClassSpecHelpers
     Commander::Runner.instance
   end
 
-  #
-  # 
-  #
-  def expects_running(*args, &block)
-    mock_terminal
-    r = new_command_runner *args do
-      instance #ensure instance is created before subject :new is mocked
-      subject.should_receive(:new).any_number_of_times.and_return(instance)
-      RHC::Commands.to_commander
-    end
-    lambda { r.run! }
-  end
-  def command_for(*args)
-    mock_terminal
-    r = new_command_runner *args do
-      instance #ensure instance is created before subject :new is mocked
-      subject.should_receive(:new).any_number_of_times.and_return(instance)
-      RHC::Commands.to_commander
-    end
-    command = nil
-    RHC::Commands.stub(:execute){ |cmd, method, args| command = cmd; 0 }
-    r.run!
-    command
-  end
-
   class MockHighLineTerminal < HighLine
     def initialize(input, output)
       super
@@ -224,23 +279,6 @@ module ClassSpecHelpers
     $terminal = old_terminal
   end
 
-  def run(input=[])
-    #Commander::Runner.instance_variable_set :"@singleton", nil
-    mock_terminal
-    input.each { |i| $terminal.write_line(i) }
-    $terminal.close_write
-    #"#{@output.string}\n#{$stderr.string}"
-    RHC::CLI.start(arguments)
-  end
-
-  def run_output(input=[])
-    run(input)
-  rescue SystemExit => e
-    "#{@output.string}\n#{$stderr.string}#{e}"
-  else
-    "#{@output.string}\n#{$stderr.string}"
-  end
-
   #
   # usage: stub_request(...).with(&user_agent_header)
   #
@@ -329,6 +367,48 @@ module CommanderInvocationMatchers
   end  
 end
 
+module ColorMatchers
+  COLORS = {
+    :green => 32,
+    :yellow => 33,
+    :cyan => 36,
+    :red => 31,
+    :clear => 0
+  }
+
+  Spec::Matchers.define :be_colorized do |msg,color|
+    match do |actual|
+      actual == colorized_message(msg,color)
+    end
+
+    failure_message_for_should do |actual|
+      failure_message(actual,msg,color)
+    end
+
+    failure_message_for_should_not do |actual|
+      failure_message(actual,msg,color)
+    end
+
+    def failure_message(actual,msg,color)
+      "expected: #{colorized_message(msg,color).inspect}\n" +
+      "     got: #{actual.inspect}"
+    end
+
+    def ansi_code(color)
+      "\e[#{ColorMatchers::COLORS[color]}m"
+    end
+
+    def colorized_message(msg,color)
+      [
+        ansi_code(color),
+        msg,
+        ansi_code(:clear),
+        "\n"
+      ].join('')
+    end
+  end
+end
+
 def mac?
   RbConfig::CONFIG['host_os'] =~ /^darwin/
 end
@@ -336,7 +416,10 @@ end
 Spec::Runner.configure do |config|
   config.include(ExitCodeMatchers)
   config.include(CommanderInvocationMatchers)
+  config.include(ColorMatchers)
   config.include(ClassSpecHelpers)
+  config.include(CommandHelpers)
+  config.extend(CommandExampleHelpers)
 end
 
 module TestEnv

data/spec/wizard_spec_helper.rb

@@ -37,6 +37,7 @@ module WizardStepsHelper
     RHC::Vendor::ParseConfig.new(current_config_path).tap do |cp|
       cp["default_rhlogin"].should == username
       cp["libra_server"].should == mock_uri
+      cp["use_authorization_tokens"].should == 'false'
     end
   end