rest_client_spec.rb

require 'base64'
require 'spec_helper'
require 'stringio'
require 'rest_spec_helper'
require 'rhc/rest'

module RHC
  module Rest
    describe Client do

      after{ ENV['http_proxy'] = nil }
      after{ ENV['HTTP_PROXY'] = nil }

      it 'should set the proxy protocol if it is missing' do
        ENV['http_proxy'] = 'foo.bar.com:8081'
        expect{ RHC::Rest::Client.new.send(:httpclient_for, {}) }.to raise_error(ArgumentError)
      end

      it 'should not alter the proxy protocol if it is present' do
        ENV['http_proxy'] = 'http://foo.bar.com:8081'
        RHC::Rest::Client.new.send(:httpclient_for, {}).proxy.to_s.should == URI.parse(ENV['http_proxy']).to_s
      end

      it 'should not affect the proxy protocol if nil' do
        ENV['http_proxy'] = nil
        RHC::Rest::Client.new.send(:httpclient_for, {}).proxy.should be_nil
        ENV['http_proxy'].should be_nil
      end

      let(:endpoint){ mock_href }
      let(:username){ nil }
      let(:password){ nil }
      let(:use_debug){ false }
      let(:client) do
        respond_to?(:spec_versions) ?
          RHC::Rest::Client.new(endpoint, username, password, use_debug, spec_versions) :
          RHC::Rest::Client.new(endpoint, username, password, use_debug)
      end

      let(:client_links)   { mock_response_links(mock_client_links) }
      let(:domain_0_links) { mock_response_links(mock_domain_links('mock_domain_0')) }
      let(:domain_1_links) { mock_response_links(mock_domain_links('mock_domain_1')) }
      let(:app_0_links)    { mock_response_links(mock_app_links('mock_domain_0', 'mock_app')) }
      let(:user_links)     { mock_response_links(mock_user_links) }
      let(:key_links)      { mock_response_links(mock_key_links) }
      let(:api_links)      { client_links }

      context "#new" do
        before do
          stub_api_request(:get, '').
            to_return({ :body   => { :data => client_links, :supported_api_versions => [1.0, 1.1] }.to_json,
                        :status => 200
                      })
          stub_api_request(:get, 'api_error').
            to_raise(HTTPClient::BadResponseError.new('API Error'))
          stub_api_request(:get, 'other_error').
            to_raise(StandardError.new('Other Error'))
        end

        it "returns a client object from the required arguments" do
          credentials = Base64.strict_encode64(mock_user + ":" + mock_pass)
          client.api.send(:links).should == client_links
        end
        context "against an endpoint that won't connect" do
          let(:endpoint){ mock_href('api_error') }
          it "raises an error message" do
            expect{ client.api }.to raise_error
          end
        end
        context "against an endpoint that has a generic error" do
          let(:endpoint){ mock_href('other_error') }
          it "raises a generic error for any other error condition" do
            expect{ client.api }.to raise_error(RHC::Rest::ConnectionException, "An unexpected error occured: Other Error")
          end
        end
      end

      describe "#new" do
        context "when server supports API versions [1.0, 1.1]" do
          before :each do
            stub_api_request(:get, '').
              to_return({ :body   => { :data => client_links, :supported_api_versions => [1.0, 1.1] }.to_json,
                          :status => 200
                        })
            stub_api_request(:get, 'api_error').
              to_raise(HTTPClient::BadResponseError.new('API Error'))
            stub_api_request(:get, 'other_error').
              to_raise(StandardError.new('Other Error'))
          end

          context "when client is instantiated with [1.0, 1.1] as the preferred API versions" do
            let(:spec_versions){ [1.0, 1.1] }
            it "settles on 1.1 as the API version" do
              client.api.api_version_negotiated.should == 1.1
            end
          end

          context "when client is instantiated with [1.1, 1.0] as the preferred API versions" do
            let(:spec_versions){ [1.1, 1.0] }
            it "settles on 1.0 as the API version" do
              client.api.api_version_negotiated.should == 1.0
            end
          end

          context "when client is instantiated with [1.2, 1.3] as the preferred API versions" do
            let(:spec_versions){ [1.2, 1.3] }
            it "fails to negotiate an agreeable API version" do
              client.api.api_version_negotiated.should be_nil
            end
          end

          context "when client is instantiated with [1.1, 1.0, 1.3] as the preferred API versions" do
            let(:spec_versions){ [1.1, 1.0, 1.3] }
            it "settles on 1.0 as the API version" do
              client.api.api_version_negotiated.should == 1.0
            end
          end
        end
      end

      context "with an instantiated client " do
        before do
          stub_api_request(:get, '').
            to_return({ :body   => {
                          :data => api_links,
                          :supported_api_versions => [1.0, 1.1]
                        }.to_json,
                        :status => 200
                      })
        end

        context "#add_domain" do
          before do
            stub_api_request(:any, api_links['ADD_DOMAIN']['relative']).
              to_return({ :body   => {
                            :type => 'domain',
                            :supported_api_versions => [1.0, 1.1],
                            :data => {
                              :id    => 'mock_domain',
                              :links => mock_response_links(mock_domain_links('mock_domain')),
                            }
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns a domain object" do
            domain = client.add_domain('mock_domain')
            domain.class.should == RHC::Rest::Domain
            domain.id.should == 'mock_domain'
            domain.send(:links).should ==
              mock_response_links(mock_domain_links('mock_domain'))
          end
        end

        context "#domains" do
          before(:each) do
            stub_api_request(:any, api_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
                        }).
              to_return({ :body   => {
                            :type => 'domains',
                            :data => []
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns a list of existing domains" do
            domains = client.domains
            domains.length.should equal(2)
            (0..1).each do |idx|
              domains[idx].class.should == RHC::Rest::Domain
              domains[idx].id.should    == "mock_domain_#{idx}"
              domains[idx].send(:links).should ==
                mock_response_links(mock_domain_links("mock_domain_#{idx}"))
            end
          end
          it "returns an empty list when no domains exist" do
            # Disregard the first response; this is for the previous expectiation.
            domains = client.domains
            client.instance_variable_set(:@domains, nil)
            domains = client.domains
            domains.length.should equal(0)
          end
        end

        context "#find_domain" do
          context "when server does not support SHOW_DOMAIN" do 
            before do
              stub_api_request(:any, api_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
                          })
            end
            it "returns a domain object for matching domain IDs" do
              match = nil
              expect { match = client.find_domain('mock_domain_0') }.to_not raise_error
              match.id.should == 'mock_domain_0'
              match.class.should == RHC::Rest::Domain
            end
            it "returns a domain object for matching case-insensitive domain IDs" do
              match = nil
              expect { match = client.find_domain('MOCK_DOMAIN_0') }.to_not raise_error
              match.id.should == 'mock_domain_0'
              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') }.to raise_error(RHC::Rest::DomainNotFoundException)
            end
          end

          context "when server supports SHOW_DOMAIN" do
            let(:api_links){ client_links.merge!(mock_response_links([['SHOW_DOMAIN', 'domains/:name', 'get']])) }
            before do 
              stub_api_request(:any, api_links['SHOW_DOMAIN']['relative'].gsub(/:name/, 'mock_domain_0')).
                to_return({ :body   => {
                              :type => 'domain',
                              :data =>
                              { :id    => 'mock_domain_0',
                                 :links => mock_response_links(mock_domain_links('mock_domain_0')),
                               }
                            }.to_json,
                            :status => 200
                          })
              stub_api_request(:any, api_links['SHOW_DOMAIN']['relative'].gsub(/:name/, 'mock_domain_%^&')).
                to_return({ :body   => {
                              :type => 'domain',
                              :data =>
                              { :id    => 'mock_domain_%^&',
                                 :links => mock_response_links(mock_domain_links('mock_domain_0')),
                               }
                            }.to_json,
                            :status => 200
                          })                
              stub_api_request(:any, api_links['SHOW_DOMAIN']['relative'].gsub(/:name/, 'mock_domain_2')).
                to_return({ :body => {:messages => [{:exit_code => 127}]}.to_json,
                            :status => 404
                          })                
            end
            it "returns a domain object for matching domain IDs" do
              match = nil
              expect { match = client.find_domain('mock_domain_0') }.to_not raise_error
              match.id.should == 'mock_domain_0'
              match.class.should == RHC::Rest::Domain
            end
            it "encodes special characters" do
              match = nil
              expect { match = client.find_domain('mock_domain_%^&') }.to_not raise_error
              match.id.should == 'mock_domain_%^&'
              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') }.to raise_error(RHC::Rest::DomainNotFoundException)
            end
          end
        end

        context "when server supports LIST_DOMAINS_BY_OWNER" do
          let(:api_links){ client_links.merge!(mock_response_links([['LIST_DOMAINS_BY_OWNER', 'domains', 'get']])) }
          before do 
            stub_api_request(:any, "#{api_links['LIST_DOMAINS_BY_OWNER']['relative']}?owner=@self").
              to_return({ :body   => {
                            :type => 'domains',
                            :data => [{ 
                              :id    => 'mock_domain_0',
                              :links => mock_response_links(mock_domain_links('mock_domain_0')),
                            }]
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns owned domains when called" do
            match = nil
            expect { match = client.owned_domains }.to_not raise_error
            match.length.should == 1
            match.first.id.should == 'mock_domain_0'
            match.first.class.should == RHC::Rest::Domain
          end
        end

        context "find_application" do
          let(:mock_domain){ 'mock_domain_0' }
          let(:mock_app){ 'mock_app' }
          let(:missing){ 'no_match' }
          before(:each) do
            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 == mock_domain
              match.send(:links).should     ==
                mock_response_links(mock_app_links(mock_domain, mock_app))
          end
          it "Raises an exception when no matching applications can be found" do
            expect { client.find_application(mock_domain, missing) }.to 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) }.to raise_error(RHC::Rest::DomainNotFoundException)
          end
        end

        describe RHC::Rest::Cartridge do
          subject do
            RHC::Rest::Cartridge.new({
              :name => 'foo',
              :links => mock_response_links([
                ['GET', 'broker/rest/cartridge', 'get']
              ])}, client)
          end
          context "when several messages are present" do
            before do
              stub_api_request(:get, 'broker/rest/cartridge', true).
                with(:query => {:include => 'status_messages'}).
                to_return(:body => {
                  :type => 'cartridge',
                  :data => {
                    :status_messages => [{:message => 'Test'}]
                  }
                }.to_json)
            end
            its(:status){ should == [{'message' => 'Test'}] }
          end
        end

        context "#cartridges" do
          before(:each) do
            stub_api_request(:any, api_links['LIST_CARTRIDGES']['relative']).
              to_return({ :body   => {
                            :type => 'cartridges',
                            :data =>
                            [{ :name  => 'mock_cart_0',
                               :type  => 'mock_cart_0_type',
                               :links => mock_response_links(mock_cart_links('mock_cart_0')),
                             },
                             { :name  => 'mock_cart_1',
                               :type  => 'mock_cart_1_type',
                               :links => mock_response_links(mock_cart_links('mock_cart_1')),
                             }]
                          }.to_json,
                          :status => 200
                        }).
              to_return({ :body   => {
                            :type => 'cartridges',
                            :data => []
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns a list of existing cartridges" do
            carts = client.cartridges
            carts.length.should equal(2)
            (0..1).each do |idx|
              carts[idx].class.should == RHC::Rest::Cartridge
              carts[idx].name.should  == "mock_cart_#{idx}"
              carts[idx].type.should  == "mock_cart_#{idx}_type"
              carts[idx].send(:links).should ==
                mock_response_links(mock_cart_links("mock_cart_#{idx}"))
            end
          end
          it "caches cartridges on the client" do
            # Disregard the first response; this is for the previous expectiation.
            old = client.cartridges.length
            client.cartridges.length.should equal(old)
            client.instance_variable_set(:@cartridges, nil)
            client.cartridges.length.should equal(0)
          end
        end

        context "#find_cartridges" do
          before(:each) do
            stub_api_request(:any, api_links['LIST_CARTRIDGES']['relative']).
              to_return({ :body   => {
                            :type => 'cartridges',
                            :data =>
                            [{ :name  => 'mock_cart_0',
                               :type  => 'mock_cart_0_type',
                               :links => mock_response_links(mock_cart_links('mock_cart_0')),
                             },
                             { :name  => 'mock_cart_1',
                               :type  => 'mock_cart_1_type',
                               :links => mock_response_links(mock_cart_links('mock_cart_1')),
                             },
                             { :name  => 'mock_nomatch_cart_0',
                               :type  => 'mock_nomatch_cart_0_type',
                               :links => mock_response_links(mock_cart_links('mock_nomatch_cart_0')),
                             }
                            ]
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns a list of cartridge objects for matching cartridges" do
            matches = client.find_cartridges('mock_cart_0')
            matches.length.should equal(1)
            matches[0].class.should == RHC::Rest::Cartridge
            matches[0].name.should  == 'mock_cart_0'
            matches[0].type.should  == 'mock_cart_0_type'
            matches[0].send(:links).should ==
              mock_response_links(mock_cart_links('mock_cart_0'))
          end
          it "returns an empty list when no matching cartridges can be found" do
            matches = client.find_cartridges('no_match')
            matches.length.should equal(0)
          end
          it "returns multiple cartridge matches" do
            matches = client.find_cartridges :regex => "mock_cart_[0-9]"
            matches.length.should equal(2)
          end
        end

        context "#user" do
          before(:each) do
            stub_api_request(:any, api_links['GET_USER']['relative']).
              to_return({ :body   => {
                            :type => 'user',
                            :data =>
                            { :login => mock_user,
                              :links => mock_response_links(mock_user_links)
                            }
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns the user object associated with this client connection" do
            user = client.user
            user.class.should  == RHC::Rest::User
            user.login.should  == mock_user
            user.send(:links).should  == mock_response_links(mock_user_links)
          end
        end

        context "#find_key" do
          before(:each) do
            stub_api_request(:any, api_links['GET_USER']['relative']).
              to_return({ :body   => {
                            :type => 'user',
                            :data =>
                            { :login => mock_user,
                              :links => mock_response_links(mock_user_links)
                            }
                          }.to_json,
                          :status => 200
                        })
            stub_api_request(:any, user_links['LIST_KEYS']['relative']).
              to_return({ :body   => {
                            :type => 'keys',
                            :data =>
                            [{ :name    => 'mock_key_0',
                               :type    => 'mock_key_0_type',
                               :content => '123456789:0',
                               :links   => mock_response_links(mock_key_links('mock_key_0'))
                             },
                             { :name    => 'mock_key_1',
                               :type    => 'mock_key_1_type',
                               :content => '123456789:1',
                               :links   => mock_response_links(mock_key_links('mock_key_1'))
                             }]
                          }.to_json,
                          :status => 200
                        })
          end
          it "returns a list of key objects for matching keys" do
            key = nil
            expect { key = client.find_key('mock_key_0') }.to_not raise_error

            key.class.should   == RHC::Rest::Key
            key.name.should    == 'mock_key_0'
            key.type.should    == 'mock_key_0_type'
            key.content.should == '123456789:0'
            key.send(:links).should   ==
              mock_response_links(mock_key_links('mock_key_0'))
          end
          it "raise an error when no matching keys can be found" do
            expect { client.find_key('no_match') }.to raise_error(RHC::KeyNotFoundException)
          end
        end

        context "#delete_key" do
          before(:each) do
            stub_api_request(:any, api_links['GET_USER']['relative']).
              to_return({ :body   => {
                            :type => 'user',
                            :data =>
                            { :login => mock_user,
                              :links => mock_response_links(mock_user_links)
                            }
                          }.to_json,
                          :status => 200
                        })
            stub_api_request(:any, user_links['LIST_KEYS']['relative']).
              to_return({ :body   => {
                            :type => 'keys',
                            :data =>
                            [{ :name    => 'mock_key_0',
                               :type    => 'mock_key_0_type',
                               :content => '123456789:0',
                               :links   => mock_response_links(mock_key_links('mock_key_0'))
                             },
                             { :name    => 'mock_key_1',
                               :type    => 'mock_key_1_type',
                               :content => '123456789:1',
                               :links   => mock_response_links(mock_key_links('mock_key_1'))
                             }]
                          }.to_json,
                          :status => 200
                        })

            stub_api_request(:post, key_links['DELETE']['relative']).
              to_return({ :body   => {}.to_json,
                          :status => 200
                        })
          end

          it "should delete keys" do
            expect { client.delete_key('mock_key_0') }.to be_true
          end

          it 'raises an error if nonexistent key is requested' do
            expect { client.find_key('no_match') }.to raise_error(RHC::KeyNotFoundException)
          end
        end
      end

      context "when server supports API versions 1.0 and 1.1" do
        before :each do
          stub_api_request(:get, '').
            to_return({ :body   => {
                          :data => api_links,
                          :supported_api_versions => [1.0, 1.1]
                        }.to_json,
                        :status => 200
                      })
        end

        context "when client supports API version 1.1" do
          let(:spec_versions){ [1.1] }

          describe "#api_version_negotiated" do
            it "returns 1.1" do
              client.api.api_version_negotiated.to_s.should == '1.1'
            end
          end
        end

        context "when client supports only API version 1.2" do
          let(:spec_versions){ [1.2] }

          describe "#api_version_negotiated" do
            it 'returns nil' do
              client.api.api_version_negotiated.should be_nil
            end
          end
        end

        context "when client supports only API version 0.9" do
          describe "#new" do
            let(:spec_versions){ [0.9] }
            it "warns user that it is outdated" do
              capture do
                client.api
                @output.rewind
                @output.read.should =~ /client version may be outdated/
              end
            end
          end
        end
      end

      describe "#supports_sessions?" do
        before{ subject.should_receive(:api).at_least(2).times.and_return(double) }
        context "with ADD_AUTHORIZATION link" do
          before{ subject.api.should_receive(:supports?).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?).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

module RHC
  module Rest
    describe HTTPClient do
    end

    describe WWWAuth::DeferredCredential do
      subject{ described_class.new(nil, nil) }
      its(:user){ should be_nil }
      its(:passwd){ should be_nil }

      context "with a username and password" do
        subject{ described_class.new(username, password) }
        let(:username){ 'a_user' }
        let(:password){ 'a_password' }

        its(:user){ should == username }
        its(:passwd){ should == password }
        its(:to_str){ should == ["#{username}:#{password}"].pack('m').tr("\n", '') }
      end

      context "with a deferred username and password" do
        subject{ described_class.new(username, password) }
        let(:username){ lambda{ 'a_user' } }
        let(:password){ lambda{ 'a_password' } }

        its(:user){ should == username.call }
        its(:passwd){ should == password.call }
        its(:to_str){ should == ["#{username.call}:#{password.call}"].pack('m').tr("\n", '') }
      end      
    end
  end
end