rhc 1.28.5 → 1.29.7

data/lib/rhc/auth/basic.rb

@@ -12,7 +12,7 @@ module RHC::Auth
       @skip_interactive = !@password.nil?
     end
 
-    def to_request(request)
+    def to_request(request, client=nil)
       request[:user] ||=
         lambda{ username || (request[:lazy_auth] != true && ask_username) || nil }
       request[:password] ||=
@@ -21,10 +21,10 @@ module RHC::Auth
     end
 
     def retry_auth?(response, client)
-      if response.status == 401
-        credentials_rejected
-      else
+      if response && response.status != 401
         false
+      else
+        credentials_rejected
       end
     end
 
@@ -40,6 +40,10 @@ module RHC::Auth
       "Please sign in to start a new session to #{openshift_server}."
     end
 
+    def token_store_user_key
+      username
+    end
+
     attr_reader :username
 
     protected

data/lib/rhc/auth/token.rb

@@ -14,31 +14,27 @@ module RHC::Auth
       read_token
     end
 
-    def to_request(request)
-      if auth and !token and (!@allows_tokens or @can_get_token == false)
-        debug "Bypassing token auth"
-        auth.to_request(request)
-      else
-        # If no token is available an empty one will be submitted at this
-        # point.  This is actually required in order for the retry logic to be
-        # triggered in all cases.
-        #
-        # Previously a request with no authentication was submitted to trigger
-        # this behavior but it was found not to work in certain scenarios where
-        # Broker authentication is handled by Apache.  In those cases a 403 is
-        # returned and not secondary authentication attempt is made.
+    def to_request(request, client=nil)
+      if !token and auth and @allows_tokens and client and client.supports_sessions?
+        debug "Attempting to generate token"
+        token_rejected(nil, client)
+      end
+
+      if token
         debug "Using token authentication"
         (request[:headers] ||= {})['authorization'] = "Bearer #{token}"
+      elsif auth
+        debug "Bypassing token auth"
+        auth.to_request(request, client)
       end
       request
     end
 
     def retry_auth?(response, client)
-      case response.status
-      when 401
-        token_rejected(response, client)
-      else
+      if response && response.status != 401
         false
+      else
+        token_rejected(response, client)
       end
     end
 
@@ -46,8 +42,12 @@ module RHC::Auth
       auth && auth.respond_to?(:username) && auth.username || options[:username]
     end
 
+    def token_store_user_key
+      auth && auth.respond_to?(:token_store_user_key) && auth.token_store_user_key || username
+    end
+
     def save(token)
-      store.put(username, openshift_server, token) if store
+      store.put(token_store_user_key, openshift_server, token) if store
       @token = token
     end
 
@@ -101,7 +101,7 @@ module RHC::Auth
       end
 
       def read_token
-        @token ||= store.get(username, openshift_server) if store
+        @token ||= store.get(token_store_user_key, openshift_server) if store
       end
 
       def cannot_retry?

data/lib/rhc/auth/x509.rb

@@ -4,33 +4,23 @@ module RHC::Auth
       @options = args[0] || Commander::Command::Options.new
     end
 
-    def to_request(request)
+    def to_request(request, client=nil)
       request[:client_cert] = certificate_file(options.ssl_client_cert_file)
-      request[:client_key] = rsa_key_file(options.ssl_client_key_file)
+      request[:client_key] = certificate_key(options.ssl_client_key_file)
       request
     end
 
-    def certificate_file(file)
-      file && OpenSSL::X509::Certificate.new(IO.read(File.expand_path(file)))
-    rescue => e
-      debug e
-      raise OptionParser::InvalidOption.new(nil, "The certificate '#{file}' cannot be loaded: #{e.message} (#{e.class})")
-    end
-
-    def rsa_key_file(file)
-      file && OpenSSL::PKey::RSA.new(IO.read(File.expand_path(file)))
-    rescue => e
-      debug e
-      raise OptionParser::InvalidOption.new(nil, "The RSA key '#{file}' cannot be loaded: #{e.message} (#{e.class})")
+    def token_store_user_key
+      certificate_fingerprint(options.ssl_client_cert_file)
     end
 
     def retry_auth?(response, client)
       # This is really only hit in the case of token auth falling back to x509.
       # x509 auth doesn't usually get 401s.
-      if response.status == 401
-        true
-      else
+      if response && response.status != 401
         false
+      else
+        true
       end
     end
 

data/lib/rhc/commands/region.rb

@@ -18,8 +18,13 @@ module RHC::Commands
         display_region(region)
       end
 
-      paragraph{ say "To create an app in a specific region use 'rhc create-app <name> <cartridge> --region <region>'." }
-
+      paragraph do
+        if regions.find{|r| r.allow_selection?}.blank?
+          warn "Regions can't be explicitly provided by users and will be automatically selected by the system."
+        else
+          say "To create an app in a specific region use 'rhc create-app <name> <cartridge> --region <region>'."
+        end
+      end
       0
     end
 

data/lib/rhc/commands/server.rb

@@ -86,6 +86,7 @@ module RHC::Commands
     option ["--timeout SECONDS"], "The default timeout for operations on this server", :type => Integer
     option ["--ssl-ca-file FILE"], "An SSL certificate CA file (may contain multiple certs) to be used on this server", :type => CertificateFile, :optional => true
     option ["--ssl-client-cert-file FILE"], "An SSL x509 client certificate file to be used on this server", :type => CertificateFile, :optional => true
+    option ["--ssl-client-key-file FILE"], "An RSA client certificate key", :type => CertificateKey, :optional => true
     option ["--ssl-version VERSION"], "The version of SSL to use to be used on this server", :type => SSLVersion, :optional => true
     def add(hostname, nickname)
       raise ArgumentError, "The --use and --skip-wizard options cannot be used together." if options.use && options.skip_wizard
@@ -177,6 +178,7 @@ module RHC::Commands
     option ["--timeout SECONDS"], "The default timeout for operations on this server", :type => Integer
     option ["--ssl-ca-file FILE"], "An SSL certificate CA file (may contain multiple certs) to be used on this server", :type => CertificateFile, :optional => true
     option ["--ssl-client-cert-file FILE"], "An SSL x509 client certificate file to be used on this server", :type => CertificateFile, :optional => true
+    option ["--ssl-client-key-file FILE"], "An RSA client certificate key", :type => CertificateKey, :optional => true
     option ["--ssl-version VERSION"], "The version of SSL to use to be used on this server", :type => SSLVersion, :optional => true
     def configure(server)
       raise ArgumentError, "The --use and --skip-wizard options cannot be used together." if options.use && options.skip_wizard

data/lib/rhc/config.rb

@@ -130,7 +130,6 @@ module RHC
 
       @default_proxy = nil
 
-      @defaults.add('insecure', false)
       @defaults.add('libra_server', openshift_online_server)
 
       @env_config.add('libra_server', libra_server_env) if libra_server_env
@@ -367,7 +366,12 @@ module RHC
 
       def servers_config
         lazy_init
-        (servers.find(self['libra_server']).to_config rescue nil) || (servers.list.first.to_config rescue nil)
+        libra_server_conf = (@local_config['libra_server'] rescue nil) || (@global_config['libra_server'] rescue nil)
+        if libra_server_conf
+          servers.find(libra_server_conf).to_config rescue nil
+        else
+          servers.list.first.to_config rescue nil
+        end
       end
 
       def lazy_init

data/lib/rhc/helpers.rb

@@ -154,6 +154,7 @@ module RHC
     end
 
     OptionParser.accept(CertificateFile = Class.new) {|s| certificate_file(s); s}
+    OptionParser.accept(CertificateKey = Class.new) {|s| certificate_key(s); s}
 
     def role_name(s)
       ROLES[s.downcase]
@@ -186,7 +187,17 @@ module RHC
     end
 
     def token_for_user
-      options.token or (token_store.get(options.rhlogin, options.server) if options.rhlogin && options.use_authorization_tokens)
+      return options.token if options.token
+      return nil unless options.use_authorization_tokens
+
+      token_store_user_key = if options.ssl_client_cert_file
+        certificate_fingerprint(options.ssl_client_cert_file)
+      else
+        options.rhlogin
+      end
+
+      return nil if token_store_user_key.nil?
+      token_store.get(token_store_user_key, options.server)
     end
 
     def client_from_options(opts)
@@ -213,11 +224,15 @@ module RHC
       raise OptionParser::InvalidOption.new(nil, "The certificate '#{file}' cannot be loaded: #{e.message} (#{e.class})")
     end
 
+    def certificate_fingerprint(file)
+      Digest::SHA1.hexdigest(certificate_file(file).to_der)
+    end
+
     def certificate_key(file)
       file && OpenSSL::PKey::RSA.new(IO.read(File.expand_path(file)))
     rescue => e
       debug e
-      raise OptionParser::InvalidOption.new(nil, "The key '#{file}' cannot be loaded: #{e.message} (#{e.class})")
+      raise OptionParser::InvalidOption.new(nil, "The RSA key '#{file}' cannot be loaded: #{e.message} (#{e.class})")
     end
 
     def parse_ssl_version(version)

data/lib/rhc/output_helpers.rb

@@ -73,7 +73,7 @@ module RHC
 
     def display_server(server)
       paragraph do
-        header ["Server '#{server.nickname || to_host(server.hostname)}'", ("(in use)" if server.default?)], {:color => (:green if server.default?)} do
+        header ["Server '#{server.nickname || to_host(server.hostname)}'", (server.persisted? ? ("(in use)" if server.default?) : "(not configured, run 'rhc setup')")], {:color => (server.persisted? ? (:green if server.default?) : :yellow)} do
           section(:bottom => 1) do
             say format_table \
               nil,
@@ -90,7 +90,7 @@ module RHC
               ),
               {
                 :delete => true,
-                :color => (:green if server.default?)
+                :color => (server.persisted? ? (:green if server.default?) : :yellow)
               }
           end
         end

data/lib/rhc/rest/api.rb

@@ -14,7 +14,7 @@ module RHC
           :url => client.url,
           :method => :get,
           :accept => :json,
-          :lazy_auth => true,
+          :no_auth => true,
         })
         debug "Server supports API versions #{@server_api_versions.join(', ')}"
 
@@ -28,7 +28,7 @@ module RHC
               :method => :get,
               :accept => :json,
               :api_version => api_version_negotiated,
-              :lazy_auth => true,
+              :no_auth => true,
             })
           end
         else

data/lib/rhc/rest/client.rb

@@ -564,8 +564,9 @@ module RHC
           options[:send_timeout] ||= options[:timeout] || 0
           options[:timeout] = nil
 
-          if auth = options[:auth] || self.auth
-            auth.to_request(options)
+          auth = (options[:auth] || self.auth) unless options[:no_auth]
+          if auth
+            auth.to_request(options, self)
           end
 
           headers = (self.headers.to_a + (options.delete(:headers) || []).to_a).inject({}) do |h,(k,v)|
@@ -597,6 +598,7 @@ module RHC
 
           # remove all unnecessary options
           options.delete(:lazy_auth)
+          options.delete(:no_auth)
           options.delete(:accept)
 
           args = [options.delete(:method), options.delete(:url), query, payload, headers, true]

data/lib/rhc/rest/mock.rb

@@ -271,8 +271,8 @@ module RHC::Rest::Mock
       stub_api_request(:get, 'broker/rest/cartridges', with_auth).to_return(simple_carts)
     end
 
-    def stub_simple_regions(empty=false, with_auth=mock_user_auth)
-      stub_api_request(:get, 'broker/rest/regions', with_auth).to_return(simple_regions(empty))
+    def stub_simple_regions(empty=false, allow_selection=true, with_auth=mock_user_auth)
+      stub_api_request(:get, 'broker/rest/regions', with_auth).to_return(simple_regions(empty, allow_selection))
     end
 
     def define_exceptional_test_on_wizard
@@ -327,13 +327,13 @@ module RHC::Rest::Mock
       }
     end
 
-    def simple_regions(empty=false)
+    def simple_regions(empty=false, allow_selection=true)
       {
         :body => {
           :type => 'regions',
           :data => empty ? [] : [
-            {:id => 'region0001', :default => false, :name => 'north', :description => 'Servers in the north of US', :zones => [{:name => 'west', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}, {:name => 'east', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}]},
-            {:id => 'region0002', :default => true, :name => 'south', :zones => [{:name => 'east', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}]},
+            {:id => 'region0001', :default => false, :name => 'north', :allow_selection => allow_selection, :description => 'Servers in the north of US', :zones => [{:name => 'west', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}, {:name => 'east', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}]},
+            {:id => 'region0002', :default => true, :name => 'south', :allow_selection => allow_selection, :zones => [{:name => 'east', :created_at => '2014-01-01T01:00:00Z', :updated_at => '2014-01-01T01:00:00Z'}]},
           ],
         }.to_json
       }

data/lib/rhc/rest/region.rb

@@ -1,11 +1,15 @@
 module RHC::Rest
   class Region < Base
-    define_attr :id, :name, :description, :default
+    define_attr :id, :name, :description, :default, :allow_selection
 
     def default?
       !!default
     end
 
+    def allow_selection?
+      !!allow_selection
+    end
+
     def uuid
       client.api_version_negotiated >= 1.6 ? attributes['id'] : attributes['uuid']
     end

data/lib/rhc/servers.rb

@@ -10,10 +10,11 @@ module RHC
     attr_accessor :use_authorization_tokens, :insecure, :timeout
     attr_accessor :ssl_version, :ssl_client_cert_file, :ssl_client_key_file, :ssl_ca_file
     attr_accessor :default
+    attr_accessor :persisted
 
     def self.from_yaml_hash(hash)
       hash.symbolize_keys!
-      Server.new(hash.delete(:hostname), hash)
+      Server.new(hash.delete(:hostname), hash.merge(:persisted => true))
     end
 
     def initialize(hostname, args={})
@@ -28,12 +29,17 @@ module RHC
       @ssl_client_key_file = args[:ssl_client_key_file]
       @ssl_ca_file = args[:ssl_ca_file]
       @default = args[:default]
+      @persisted = args[:persisted]
     end
 
     def default?
       !!@default
     end
 
+    def persisted?
+      !!@persisted
+    end
+
     def designation
       @nickname || @hostname
     end
@@ -43,7 +49,7 @@ module RHC
         instance_variables.each do |k| 
           h[k.to_s.delete('@')] = instance_variable_get(k)
         end
-      end.reject{|k, v| v.nil? || k == 'default'}.inject({}){|h, (k, v)| h[k] = v.is_a?(String) || v.is_a?(Symbol) ? v.to_s : v; h }
+      end.reject{|k, v| v.nil? || k == 'default' || k == 'persisted'}.inject({}){|h, (k, v)| h[k] = v.is_a?(String) || v.is_a?(Symbol) ? v.to_s : v; h }
     end
 
     def to_config
@@ -155,14 +161,17 @@ module RHC
           :ssl_client_cert_file     => o[:ssl_client_cert_file],
           :ssl_client_key_file      => o[:ssl_client_key_file],
           :ssl_ca_file              => o[:ssl_ca_file])
-        list.each{|server| server.default = server.hostname == o[:server]}
+        list.each do |server| 
+          server.default = server.hostname == o[:server]
+          server.persisted = true if !present?
+        end
       end
     end
 
     def save!
       FileUtils.mkdir_p File.dirname(path)
       File.open(path, 'w') do |c| 
-        c.puts list.collect{|s| {'server' => s.to_yaml_hash}}.to_yaml
+        c.puts list.collect{|s| s.persisted = true; {'server' => s.to_yaml_hash}}.to_yaml
       end
       self
     end

data/spec/rhc/auth_spec.rb

@@ -251,6 +251,28 @@ describe RHC::Auth::X509 do
     end
   end
 
+  describe "#token_store_user_key" do
+    let(:cert) do
+      file = Tempfile.new('cert')
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 2
+      cert.serial = 1
+      cert.subject = OpenSSL::X509::Name.parse "/DC=org/DC=ruby-lang/CN=Ruby CA"
+      cert.issuer = cert.subject
+      cert.not_before = Time.now
+      cert.not_after = cert.not_before + 2 * 365 * 24 * 60 * 60
+      file.write(cert)
+      file.flush
+      file
+    end
+    let(:options){ Commander::Command::Options.new(:ssl_client_cert_file => cert.path) }
+    context "when the client cert is set", :focus => true do
+      it("should return the fingerprint") do
+        subject.token_store_user_key.length.should == 40
+      end
+    end
+  end
+
   describe "#to_request" do
     let(:request){ {} }
     let(:auth_hash){ {:client_cert => a_cert, :client_key => a_key} }
@@ -340,7 +362,8 @@ describe RHC::Auth::Token do
   end
 
   context "when initialized with a store" do
-    subject{ described_class.new(nil, nil, store) }
+    subject{ described_class.new(nil, auth, store) }
+    let(:auth){ double(:token_store_user_key => nil) }
     let(:store){ double }
     before{ store.should_receive(:get).with(nil, 'openshift.redhat.com').and_return(token) }
     it("should read the token for the user") do
@@ -349,11 +372,11 @@ describe RHC::Auth::Token do
   end
 
   describe "#save" do
-    subject{ described_class.new(nil, nil, store) }
+    subject{ described_class.new(nil, auth, store) }
     context "when store is set" do
+      let(:auth){ double(:token_store_user_key => 'foo') }
       let(:store){ double(:get => nil) }
       it("should call put on store") do
-        subject.should_receive(:username).and_return('foo')
         subject.should_receive(:openshift_server).and_return('bar')
         store.should_receive(:put).with('foo', 'bar', token)
         subject.save(token)
@@ -378,17 +401,51 @@ describe RHC::Auth::Token do
       end
     end
 
-    context "when token is not provided" do
-      subject{ described_class.new(nil) }
+    context "when a token is not provided when secondary auth is provided" do
+      let(:auth) { double(:can_authenticate? => true, :get_token_message => '') }
+      let(:default_options){ {:use_authorization_tokens => true} }
+      subject{ described_class.new(default_options, auth) }
+
+      context "without session support" do
+        let(:client){ double('client', :supports_sessions? => false) }
+        it("should delegate to secondary auth") do
+          auth.should_receive(:to_request).with(request, client).and_return(request)
+          subject.should_receive(:token_rejected).never
+          subject.to_request(request, client).should == {}
+        end
+      end
+
+      context "with session support" do
+        let(:client){ double('client', :supports_sessions? => true) }
+        before do
+          client.should_receive(:new_session).with(:auth => auth).and_return(auth_token)
+        end
+
+        context "when a token request fails" do
+          let(:auth_token){ nil }
+          it("should delegate to secondary auth") do
+            auth.should_receive(:retry_auth?).once.and_return(true)
+            auth.should_receive(:to_request).once.and_return(request)
+            subject.to_request(request, client).should == {}
+          end
+        end
 
-      it("should submit an empty bearer token to the server to trigger the 401 retry flow for OpenShift Enterprise"){ subject.to_request(request).should == {:headers => {'authorization' => "Bearer "}} }
+        context "when a token request succeeds" do
+          let(:auth_token){ double('auth_token', :token => token) }
+          it("should should use the newly created token") do
+            auth.should_receive(:to_request).never
+            subject.to_request(request, client).should == {:headers => {'authorization' => "Bearer #{token}"}}
+          end
+        end
+
+      end
     end
 
     context "when a parent auth class is passed" do
       subject{ described_class.new(nil, auth) }
       let(:auth){ double }
       it("should invoke the parent") do
-        auth.should_receive(:to_request).with(request).and_return(request)
+        auth.should_receive(:to_request).with(request, nil).and_return(request)
         subject.to_request(request).should == request
       end
     end

data/spec/rhc/command_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'rhc/commands/base'
 require 'rhc/exceptions'
 require 'rest_spec_helper'
+require 'tempfile'
 
 describe RHC::Commands::Base do
 
@@ -432,6 +433,29 @@ describe RHC::Commands::Base do
         end
       end
 
+      context "with tokens enabled and a certificate" do
+        let(:config){ base_config{ |c, d| d.add('use_authorization_tokens', 'true') } }
+        let(:cert) do
+          file = Tempfile.new('cert')
+          cert = OpenSSL::X509::Certificate.new
+          cert.version = 2
+          cert.serial = 1
+          cert.subject = OpenSSL::X509::Name.parse "/DC=org/DC=ruby-lang/CN=Ruby CA"
+          cert.issuer = cert.subject
+          cert.not_before = Time.now
+          cert.not_after = cert.not_before + 2 * 365 * 24 * 60 * 60
+          file.write(cert)
+          file.flush
+          file
+        end
+        let(:arguments){ ['test', '--server', mock_uri, '--ssl-client-cert-file', cert.path] }
+        it("it should generate a certificate fingerprint") do
+          command = command_for(*arguments)
+          command.should_receive(:certificate_fingerprint).with(cert.path)
+          command.send(:token_for_user)
+        end
+      end
+
       context "with username and tokens enabled against a server without tokens" do
         let!(:config){ base_config{ |c, d| d.add('use_authorization_tokens', 'true') } }
         let(:username){ 'foo' }

data/spec/rhc/commands/region_spec.rb

@@ -28,6 +28,24 @@ describe RHC::Commands::Region do
       it{ expect{ run }.to exit_with_code(0) }
     end
 
+    context 'when allowing region selection' do
+      before do 
+        stub_api 
+        stub_simple_regions(false, true)
+      end
+      it{ run_output.should match /To create an app in a specific region use/ }
+      it{ expect{ run }.to exit_with_code(0) }
+    end
+
+    context 'when not allowing region selection' do
+      before do 
+        stub_api 
+        stub_simple_regions(false, false)
+      end
+      it{ run_output.should match /Regions can't be explicitly provided by users/ }
+      it{ expect{ run }.to exit_with_code(0) }
+    end
+
     context 'without server regions' do
       before do 
         stub_api 

data/spec/rhc/commands/server_spec.rb

@@ -9,8 +9,8 @@ describe RHC::Commands::Server do
   let(:rest_client) { MockRestClient.new }
   let(:default_options){}
   let(:options){ Commander::Command::Options.new(default_options) }
-  let(:config){ RHC::Config.new.tap{ |c| c.stub(:home_dir).and_return('/home/mock_user') } }
   let(:servers){ RHC::Servers.new.tap{|c| c.stub(:home_dir).and_return('/home/mock_user') } }
+  let(:config){ RHC::Config.new.tap{ |c| c.stub(:home_dir).and_return('/home/mock_user') } }
   before do
     FakeFS.activate!
     FakeFS::FileSystem.clear
@@ -108,8 +108,6 @@ describe RHC::Commands::Server do
     end
 
     context "from express.conf and servers.yml" do
-      let(:local_config_username){ 'local_config_user' }
-      let(:local_config_password){ 'password' }
       let(:local_config_server){ 'openshift.redhat.com' }
       before do
         local_config
@@ -117,9 +115,8 @@ describe RHC::Commands::Server do
       end
       let(:arguments) { ['servers'] }
       it 'should output correctly' do 
-        run_output.should =~ /Server 'online' \(in use\)/
+        run_output.should =~ /Server 'online' \(not configured, run 'rhc setup'\)/
         run_output.should =~ /Hostname:\s+#{local_config_server}/
-        run_output.should =~ /Login:\s+#{local_config_username}/
         run_output.should =~ /Server 'server1'/
         run_output.should =~ /Hostname:\s+openshift1.server.com/
         run_output.should =~ /Login:\s+user1/
@@ -131,9 +128,28 @@ describe RHC::Commands::Server do
     end
 
     context "from express.conf and several entries on servers.yml" do
+      let(:local_config_server){ 'openshift.redhat.com' }
+      let(:entries){ 3 }
+      before do
+        local_config
+        stub_servers_yml(entries)
+      end
+      let(:arguments) { ['servers'] }
+      it 'should output correctly' do 
+        run_output.should =~ /Server 'online' \(not configured, run 'rhc setup'\)/
+        run_output.should =~ /Hostname:\s+#{local_config_server}/
+        Array(1..entries).each do |i|
+          run_output.should =~ /Server 'server#{i}'/
+          run_output.should =~ /Hostname:\s+openshift#{i}.server.com/
+        end
+      end
+      it { expect { run }.to exit_with_code(0) }
+    end
+
+    context "from express.conf and several entries on servers.yml, matching servers" do
+      let(:local_config_server){ 'openshift1.server.com' }
       let(:local_config_username){ 'local_config_user' }
       let(:local_config_password){ 'password' }
-      let(:local_config_server){ 'openshift.redhat.com' }
       let(:entries){ 3 }
       before do
         local_config
@@ -141,7 +157,27 @@ describe RHC::Commands::Server do
       end
       let(:arguments) { ['servers'] }
       it 'should output correctly' do 
-        run_output.should =~ /Server 'online' \(in use\)/
+        run_output.should =~ /Server 'server1' \(in use\)/
+        run_output.should =~ /Hostname:\s+#{local_config_server}/
+        run_output.should =~ /Login:\s+#{local_config_username}/
+        Array(1..entries).each do |i|
+          run_output.should =~ /Server 'server#{i}'/
+          run_output.should =~ /Hostname:\s+openshift#{i}.server.com/
+        end
+      end
+      it { expect { run }.to exit_with_code(0) }
+    end
+
+    context "when express.conf server is not present in servers.yml" do
+      let(:local_config_server){ 'some.openshift.mycompany.com' }
+      let(:entries){ 3 }
+      before do
+        local_config
+        stub_servers_yml(entries)
+      end
+      let(:arguments) { ['servers'] }
+      it 'should output correctly' do 
+        run_output.should =~ /Server '#{local_config_server}' \(not configured, run 'rhc setup'\)/
         run_output.should =~ /Hostname:\s+#{local_config_server}/
         Array(1..entries).each do |i|
           run_output.should =~ /Server 'server#{i}'/
@@ -501,7 +537,6 @@ describe RHC::Commands::Server do
 
   protected 
     def stub_servers_yml(entries=1, &block)
-      RHC::Servers.any_instance.stub(:save!)
       RHC::Servers.any_instance.stub(:present?).and_return(true)
       RHC::Servers.any_instance.stub(:load).and_return(
         Array(1..entries).collect do |i|
@@ -509,7 +544,8 @@ describe RHC::Commands::Server do
             :nickname => "server#{i}",
             :login => "user#{i}",
             :use_authorization_tokens => true,
-            :insecure => false)
+            :insecure => false,
+            :persisted => true)
         end.tap{|i| yield i if block_given?})
     end
 

data/spec/rhc/helpers_spec.rb

@@ -218,13 +218,13 @@ describe AllRhcHelpers do
     context "on the command line" do
       let(:arguments){ ['help', '--ssl-client-key-file=not_a_file'] }
       it{ expect{ run }.to exit_with_code(1) }
-      it{ run_output.should match("The key 'not_a_file' cannot be loaded: No such") }
+      it{ run_output.should match("The RSA key 'not_a_file' cannot be loaded: No such") }
     end
     context "via the config" do
       before{ base_config{ |c, d| d.add 'ssl_client_key_file', 'not_a_file' } }
       let(:arguments){ ['help'] }
       it{ expect{ run }.to exit_with_code(1) }
-      it{ run_output.should match("The key 'not_a_file' cannot be loaded: No such") }
+      it{ run_output.should match("The RSA key 'not_a_file' cannot be loaded: No such") }
     end
   end
 

data/spec/spec_helper.rb

@@ -404,6 +404,7 @@ module ClassSpecHelpers
     local_config.add('libra_server', server) if server
     
     c.instance_variable_set(:@local_config, local_config)
+    c.instance_variable_set(:@servers, RHC::Servers.new)
     opts = c.to_options
     opts[:rhlogin].should == user
     opts[:password].should == password

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 1
-  - 28
-  - 5
-  version: 1.28.5
+  - 29
+  - 7
+  version: 1.29.7
 platform: ruby
 authors: 
 - Red Hat
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-08-02 00:00:00 Z
+date: 2014-09-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: net-ssh