aviator 0.0.7 → 0.0.8

data/test/aviator/core/request_test.rb

@@ -25,7 +25,7 @@ class Aviator::Test
         klass = Class.new(Aviator::Request) do
                   param :someparamname, :required => true
                 end
-      
+
         obj = klass.new do |params|
           params.someparamname = 'something'
         end
@@ -35,227 +35,227 @@ class Aviator::Test
 
 
     describe '::anonymous?' do
-    
+
       it 'is false by default' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.anonymous?.must_equal false
       end
-    
-    
+
+
       it 'returns true if specified as such' do
         klass = Class.new(Aviator::Request) do
                   meta :anonymous, true
                 end
-          
+
         klass.anonymous?.must_equal true
       end
-    
+
     end
-    
-    
+
+
     describe '#anonymous?' do
-    
+
       it 'is false by default' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.new.anonymous?.must_equal false
       end
-    
-    
+
+
       it 'returns true if specified as such' do
         klass = Class.new(Aviator::Request) do
                   meta :anonymous, true
                 end
-    
+
         klass.new.anonymous?.must_equal true
       end
-    
+
     end
-    
-    
+
+
     describe '::api_version' do
-    
+
       it 'returns the api version' do
         klass = Class.new(Aviator::Request) do
           meta :api_version, :v2
         end
-    
+
         klass.api_version.must_equal :v2
       end
-    
+
     end
-    
-    
+
+
     describe '#api_version' do
-    
+
       it 'returns the api version' do
         klass = Class.new(Aviator::Request) do
           meta :api_version, :v2
         end
-    
+
         klass.new.api_version.must_equal :v2
       end
-    
+
     end
-    
-    
+
+
     describe '::body?' do
-    
+
       it 'returns false if the body method is not defined' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.body?.must_equal false
       end
-    
-    
+
+
       it 'returns true if the body method is defined' do
         klass = Class.new(Aviator::Request) do
           def body; end
         end
-    
+
         klass.body?.must_equal true
       end
-    
+
     end
-    
-    
+
+
     describe '#body?' do
-    
+
       it 'returns false if the body method is not defined' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.new.body?.must_equal false
       end
-    
-    
+
+
       it 'returns true if the body method is defined' do
         klass = Class.new(Aviator::Request) do
           def body; end
         end
-          
+
         klass.new.body?.must_equal true
       end
-    
+
     end
-    
-    
+
+
     describe '::endpoint_type' do
-    
+
       it 'returns the endpoint type' do
         klass = Class.new(Aviator::Request) do
           meta :endpoint_type, :public
         end
-    
+
         klass.endpoint_type.must_equal :public
       end
-    
+
     end
-    
-    
+
+
     describe '#endpoint_type' do
-    
+
       it 'returns the endpoint type' do
         klass = Class.new(Aviator::Request) do
           meta :endpoint_type, :whatever
         end
-    
+
         klass.new.endpoint_type.must_equal :whatever
       end
-    
+
     end
-        
-    
+
+
     describe '#http_method' do
-    
+
       it 'returns the http method if it is defined' do
         klass = Class.new(Aviator::Request) do
                   def http_method; :post; end
                 end
-    
+
         klass.new.http_method.must_equal :post
       end
-    
+
     end
-    
-    
+
+
     describe '::link' do
-    
+
       it 'adds a link to Request::links' do
         rel  = 'documentation'
         href = 'http://x.y.z'
-        
+
         klass = Class.new(Aviator::Request) do
                   link rel, href
                 end
-    
+
         expected = [
           { :rel => rel, :href => href }
         ]
-        
+
         klass.links.must_equal expected
         klass.new.links.must_equal expected
       end
-    
+
     end
-    
-    
+
+
     describe '::param' do
-    
+
       it 'is a private class method' do
         private_method = lambda { Aviator::Request.param }
         private_method.must_raise NoMethodError
-    
+
         error = private_method.call rescue $!
-    
+
         error.message.wont_be_nil
         error.message.must_include "private method"
       end
-      
-      
+
+
       it 'accepts an alias for a given parameter' do
         klass = Class.new(Aviator::Request) do
                   param :the_param, :required => true, :alias => :the_alias
                 end
-        
+
         param_val = 999
-        
+
         req = klass.new do |params|
                 params.the_param = param_val
               end
-        
+
         req.params.the_param.must_equal param_val
         req.params.the_alias.must_equal param_val
       end
-      
-      
+
+
       it 'makes the param alias assignable' do
         klass = Class.new(Aviator::Request) do
                   param :the_param, :required => true, :alias => :the_alias
                 end
-        
+
         param_val = 999
-        
+
         req = klass.new do |params|
                 params.the_alias = param_val
               end
-        
+
         req.params.the_param.must_equal param_val
         req.params.the_alias.must_equal param_val
       end
-      
-      
+
+
       it 'allows aliases to be accessible as symbols' do
         klass = Class.new(Aviator::Request) do
                   param :the_param, :required => true, :alias => :the_alias
                 end
-        
+
         param_val = 999
-        
+
         req = klass.new do |params|
                 params[:the_alias] = param_val
               end
-        
+
         req.params[:the_param].must_equal param_val
         req.params[:the_alias].must_equal param_val
       end
@@ -265,114 +265,114 @@ class Aviator::Test
         klass = Class.new(Aviator::Request) do
                   param :the_param, :required => true, :alias => :the_alias
                 end
-        
+
         param_val = 999
-        
+
         req = klass.new do |params|
                 params['the_alias'] = param_val
               end
-        
+
         req.params['the_param'].must_equal param_val
         req.params['the_alias'].must_equal param_val
       end
-    
+
     end
-    
-    
+
+
     describe '::optional_params' do
-    
+
       it 'returns an array' do
         klass = Class.new(Aviator::Request) do
                   param :whatever, :required => false
                 end
-    
+
         klass.optional_params.must_equal [:whatever]
       end
-    
+
     end
-    
-    
+
+
     describe '#optional_params' do
-    
+
       it 'returns an array' do
         klass = Class.new(Aviator::Request) do
                   param :whatever, :required => false
                 end
-    
+
         klass.new.optional_params.must_equal [:whatever]
       end
-    
+
     end
-    
-    
+
+
     describe '::required_params' do
-    
+
       it 'returns an array' do
         klass = Class.new(Aviator::Request) do
                   param :whatever, :required => true
                 end
-    
+
         klass.required_params.must_equal [:whatever]
       end
-    
+
     end
-    
-    
+
+
     describe '#required_params' do
-    
+
       it 'returns an array' do
         klass = Class.new(Aviator::Request) do
                   param :whatever, :required => true
                 end
-    
+
         request = klass.new do |params|
                     params[:whatever] = 'something'
                   end
-          
-          
+
+
         request.required_params.must_equal [:whatever]
       end
-    
+
     end
-    
-    
+
+
     describe '::url?' do
-    
+
       it 'returns false if the url method is not defined' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.url?.must_equal false
       end
-    
-    
+
+
       it 'returns true if the url method is defined' do
         klass = Class.new(Aviator::Request) do
           def url; end
         end
-          
+
         klass.url?.must_equal true
       end
-    
+
     end
-    
-    
+
+
     describe '#url?' do
-    
+
       it 'returns false if the url method is not defined' do
         klass = Class.new(Aviator::Request)
-    
+
         klass.new.url?.must_equal false
       end
-    
-    
+
+
       it 'returns true if the url method is defined' do
         klass = Class.new(Aviator::Request) do
           def url; end
         end
-    
+
         klass.new.url?.must_equal true
       end
-    
+
     end
 
 

data/test/aviator/core/service_test.rb

@@ -51,58 +51,12 @@ class Aviator::Test
       end
 
 
-      it 'can find the correct request if api version is not defined but can be inferred from host_uri' do
-        request_name = config[:auth_service][:request].to_sym
-
-        bootstrap = {
-          :auth_service => {
-            :name        => 'identity',
-            :host_uri    => 'http://devstack:5000/v2.0',
-            :request     => 'create_token'
-          }
-        }
-
-        response = service.request request_name, :session_data => bootstrap do |params|
-          config[:auth_credentials].each do |k,v|
-            params[k] = v
-          end
-        end
-
-        response.must_be_instance_of Aviator::Response
-        response.request.api_version.must_equal :v2
-        response.status.must_equal 200
-      end
-
-
-      it 'raises an error if session data does not have the endpoint information' do
-        request_name = config[:auth_service][:request].to_sym
-
-        bootstrap = Hashish.new(JSON.parse('{"access": {"token": {"issued_at": "2013-09-25T20:21:55.453783",
-          "expires": "2013-09-26T02:21:55Z", "id": "2f6bdec6cd0f49b4a60ede0cd4bf2c0d"},
-          "serviceCatalog": [], "user": {"username": "bogus",
-          "roles_links": [], "id": "447527294dae4a1788d36beb0db99c00", "roles": [],
-          "name": "bogus"}, "metadata": {"is_admin": 0, "roles":
-          []}}}'))
-
-        s = service(bootstrap)
-
-        the_method = lambda { s.request request_name }
-
-        the_method.must_raise Aviator::Service::MissingServiceEndpointError
-      end
-
-
-      it 'can find the correct request based on non-bootstrapped session data' do
-        session_data = do_auth_request.body
-
-        response = service.request :list_tenants, :session_data => session_data
-
-        response.status.must_equal 200
-      end
-
-
       it 'uses the default session data if session data is not provided' do
-        default_session_data = do_auth_request.body
+        auth_response = do_auth_request
+        default_session_data = Hashish.new({
+          :headers => auth_response.headers,
+          :body    => auth_response.body
+        })
         s = service(default_session_data)
 
         response = s.request :list_tenants
@@ -121,35 +75,25 @@ class Aviator::Test
         error.message.wont_be_nil
       end
 
-
-      it 'accepts an endpoint type option for selecting a specific request' do
-        default_session_data = do_auth_request.body
-        s = service(default_session_data)
-
-        response1 = s.request :list_tenants, :endpoint_type => 'admin'
-        response2 = s.request :list_tenants, :endpoint_type => 'public'
-
-        response1.request.url.wont_equal response2.request.url
-      end
-
     end
 
 
     describe '#request_classes' do
 
       it 'returns an array of the request classes' do
-        provider_name = config[:provider]
-        service_name  = config[:auth_service][:name]
-        service_path  = Pathname.new(__FILE__).join(
-                          '..', '..', '..', '..', 'lib', 'aviator', provider_name, service_name
-                        ).expand_path
-
-        request_files = Pathname.glob(service_path.join('**', '*.rb')) \
-                          .map{|rf| rf.to_s.match(/#{provider_name}\/#{service_name}\/([\w\/]+)\.rb$/) } \
+        provider_name  = config[:provider]
+        service_name    = config[:auth_service][:name]
+        provider_module = "Aviator::#{ provider_name.camelize }::Provider".constantize
+
+        request_file_paths = provider_module.request_file_paths(service_name)
+        request_file_paths.each{ |path| require path }
+
+        constant_parts = request_file_paths \
+                          .map{|rf| rf.to_s.match(/#{ provider_name }\/#{ service_name }\/([\w\/]+)\.rb$/) } \
                           .map{|rf| rf[1].split('/').map{|c| c.camelize }.join('::') }
 
-        classes = request_files.map do |rf|
-          "Aviator::#{provider_name.camelize}::#{service_name.camelize}::#{rf}".constantize
+        classes = constant_parts.map do |cp|
+          "Aviator::#{ provider_name.camelize }::#{ service_name.camelize }::#{ cp }".constantize
         end
 
         service.request_classes.must_equal classes
@@ -172,7 +116,7 @@ class Aviator::Test
         svc = service(bootstrap)
 
         session_data_1 = svc.default_session_data
-        session_data_2 = do_auth_request.body
+        session_data_2 = do_auth_request
 
         svc.default_session_data = session_data_2
 

data/test/aviator/core/session_test.rb

@@ -79,9 +79,9 @@ class Aviator::Test
 
         session.identity_service.must_equal keystone
 
-        new_token = session.identity_service.default_session_data[:access][:token][:id]
-        new_token.wont_equal session_data_1[:access][:token][:id]
-        keystone.default_session_data[:access][:token][:id].must_equal new_token
+        new_token = session.identity_service.default_session_data[:body][:access][:token][:id]
+        new_token.wont_equal session_data_1[:body][:access][:token][:id]
+        keystone.default_session_data[:body][:access][:token][:id].must_equal new_token
       end
 
     end # describe '#authenticate'
@@ -96,8 +96,8 @@ class Aviator::Test
         str = session.dump
 
         expected = JSON.generate({
-          :environment => session.send(:environment),
-          :auth_info => session.send(:auth_info)
+          :environment   => session.send(:environment),
+          :auth_response => session.send(:auth_response)
         })
 
         str.must_equal expected
@@ -150,7 +150,7 @@ class Aviator::Test
         # This is bad testing practice (testing a private method) but
         # I'll go ahead and do it anyway just to be sure.
         session.send(:environment).must_equal expected[:environment]
-        session.send(:auth_info).must_equal   expected[:auth_info]
+        session.send(:auth_response).must_equal expected[:auth_response]
       end
 
 
@@ -162,7 +162,7 @@ class Aviator::Test
         session  = Aviator::Session.load(session.dump)
         service  = session.identity_service
 
-        service.default_session_data.must_equal expected[:auth_info]
+        service.default_session_data.must_equal expected[:auth_response]
       end
 
     end
@@ -231,7 +231,7 @@ class Aviator::Test
         session = new_session
         session.authenticate
 
-        session.send(:auth_info)[:access][:token][:id] = 'invalidtokenid'
+        session.send(:auth_response)[:body][:access][:token][:id] = 'invalidtokenid'
 
         session.validate.must_equal false
       end