aviator 0.0.1 → 0.0.2

data/test/aviator/core/service_test.rb

@@ -0,0 +1,158 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/core/service' do
+
+    def config
+      Environment.openstack_admin
+    end
+
+
+    def do_auth_request
+      request_name = config[:auth_service][:request].to_sym
+
+      bootstrap = {
+        auth_service: config[:auth_service]
+      }
+
+      service.request request_name, session_data: bootstrap do |params|
+        config[:auth_credentials].each do |k,v|
+          params[k] = v
+        end
+      end
+    end
+        
+    
+    def klass
+      Aviator::Service
+    end
+    
+
+    def service(default_session_data=nil)
+      options = {
+        provider: config[:provider],
+        service:  config[:auth_service][:name]
+      }
+      
+      options[:default_session_data] = default_session_data unless default_session_data.nil?
+      
+      klass.new(options)
+    end
+
+
+    describe '#request' do
+
+      it 'can find the correct request based on bootstrapped session data' do
+        response = do_auth_request
+      
+        response.must_be_instance_of Aviator::Response
+        response.request.api_version.must_equal config[:auth_service][:api_version].to_sym
+      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 'can find the correct request based on non-bootstrapped session data' do
+        session_data = do_auth_request.body
+        
+        response = service.request :create_tenant, session_data: session_data do |params|
+          params.name        = 'Test Project'
+          params.description = 'This is a test'
+          params.enabled     =  true
+        end
+        
+        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
+        s = service(default_session_data)
+
+        response = s.request :create_tenant do |params|
+          params.name        = 'Test Project Too'
+          params.description = 'This is a test'
+          params.enabled     =  true
+        end
+        
+        response.status.must_equal 200
+      end
+      
+      
+      it 'raises a SessionDataNotProvidedError if there is no session data' do
+        the_method = lambda do
+          service.request :create_tenant do |params|
+            params.name        = 'Test Project Too'
+            params.description = 'This is a test'
+            params.enabled     =  true
+          end
+        end
+        
+        the_method.must_raise Aviator::Service::SessionDataNotProvidedError
+        error = the_method.call rescue $!
+        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 '#default_session_data=' do
+      
+      it 'sets the service\'s default session data' do
+        bootstrap = {
+          auth_service: {
+            name:     'identity',
+            host_uri: 'http://devstack:5000/v2.0',
+            request:  'create_token'
+          }
+        }
+        
+        svc = service(bootstrap)
+
+        session_data_1 = svc.default_session_data
+        session_data_2 = do_auth_request.body
+        
+        svc.default_session_data = session_data_2
+        
+        svc.default_session_data.wont_equal session_data_1
+        svc.default_session_data.must_equal session_data_2
+      end
+      
+    end
+
+  end
+
+end

data/test/aviator/core/session_test.rb

@@ -0,0 +1,201 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/core/session' do
+
+    def config
+      Environment
+    end
+
+
+    def log_file_path
+      Pathname.new(__FILE__).expand_path.join('..', '..', '..', '..', 'tmp', 'aviator.log')
+    end
+
+
+    def new_session
+      Aviator::Session.new(
+        config_file: config.path,
+        environment: 'test',
+        log_file:    log_file_path
+      )
+    end
+
+
+    describe '#authenticate' do      
+
+      it 'authenticates against the auth service indicated in the config file' do
+        session = new_session
+        
+        session.authenticate
+
+        session.authenticated?.must_equal true
+      end
+            
+            
+      it 'authenticates against the auth service using the credentials in the given block' do
+        session     = new_session
+        credentials = config.test[:auth_credentials]
+        
+        session.authenticate do |c|
+          c[:username] = credentials[:username]
+          c[:password] = credentials[:password]
+        end
+        
+        session.authenticated?.must_equal true
+      end
+
+
+      it 'raises an AuthenticationError when authentication fails' do
+        session     = new_session
+        credentials = config.test[:auth_credentials]
+        
+        the_method = lambda do
+          session.authenticate do |c|
+            c[:username] = 'invalidusername'
+            c[:password] = 'invalidpassword'
+          end
+        end
+        
+        the_method.must_raise Aviator::Session::AuthenticationError
+      end
+      
+      
+      it 'updates the session data of its service objects' do
+        session = new_session
+        session.authenticate
+        
+        keystone = session.identity_service
+        
+        session_data_1 = keystone.default_session_data
+        
+        session.authenticate
+        
+        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
+      end
+
+    end # describe '#authenticate'
+    
+    
+    describe '#dump' do
+      
+      it 'serializes the session data for caching' do
+        session = new_session
+        session.authenticate
+        
+        str = session.dump
+        
+        expected = JSON.generate({
+          environment: session.send(:environment),
+          auth_info: session.send(:auth_info)
+        })
+
+        str.must_equal expected
+      end
+      
+    end
+    
+    
+    describe '::load' do
+      
+      it 'creates a new instance from the given session dump' do
+        session = new_session
+        session.authenticate
+        
+        str      = session.dump
+        session  = Aviator::Session.load(str)
+        expected = JSON.parse(str).with_indifferent_access
+        
+        session.dump.must_equal str
+        session.authenticated?.must_equal true
+        
+        # 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]
+      end
+      
+      
+      it 'uses the loaded auth info for its services' do
+        session = new_session
+        session.authenticate
+        
+        expected = JSON.parse(session.dump).with_indifferent_access
+        session  = Aviator::Session.load(session.dump)
+        service  = session.identity_service
+        
+        service.default_session_data.must_equal expected[:auth_info]
+      end
+      
+    end
+    
+    
+    describe '::new' do
+      
+      it 'directs log entries to the given log file' do
+        log_file_path.delete if log_file_path.file?
+        
+        session = new_session
+        session.authenticate
+
+        log_file_path.file?.must_equal true
+      end
+      
+    end
+    
+    
+    describe '#validate' do
+      
+      it 'returns true if session is still valid' do
+        session = new_session
+        session.authenticate
+        
+        session.validate.must_equal true
+      end
+      
+      
+      it 'returns false if session is no longer valid' do
+        session = new_session
+        session.authenticate
+        
+        session.send(:auth_info)[:access][:token][:id] = 'invalidtokenid'
+        
+        session.validate.must_equal false
+      end
+      
+      
+      it 'raises an error if called before authenticating' do
+        the_method = lambda { new_session.validate }
+        
+        the_method.must_raise Aviator::Session::NotAuthenticatedError
+      end
+      
+    end
+    
+    
+    describe '#xxx_service' do
+      
+      it 'raises a NotAuthenticatedError if called without authenticating first' do
+        the_method = lambda { new_session.identity_service }
+        
+        the_method.must_raise Aviator::Session::NotAuthenticatedError
+      end
+      
+      
+      it 'returns an instance of the indicated service' do
+        session = new_session
+        session.authenticate
+        
+        session.identity_service.wont_be_nil
+      end
+      
+    end
+
+  end # describe 'aviator/core/service'
+
+end # class Aviator::Test

data/test/aviator/openstack/compute/v2/public/list_images_test.rb

@@ -0,0 +1,179 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/openstack/compute/v2/public/list_images' do
+
+    def create_request(session_data = new_session_data)
+      klass.new(session_data)
+    end
+
+
+    def new_session_data
+      service = Aviator::Service.new(
+        provider: 'openstack',
+        service:  'identity'
+      )
+      
+      bootstrap = RequestHelper.admin_bootstrap_session_data
+      
+      response = service.request :create_token, session_data: bootstrap do |params|
+        auth_credentials = Environment.openstack_admin[:auth_credentials]
+        auth_credentials.each { |key, value| params[key] = auth_credentials[key] }
+      end
+      
+      response.body
+    end
+
+
+    def helper
+      Aviator::Test::RequestHelper
+    end
+
+
+    def klass
+      path = helper.request_path('compute', 'v2', 'public', 'list_images.rb')
+      klass, request_name = Aviator::Service::RequestBuilder.build(path)
+      klass
+    end
+
+
+    validate :anonymous? do
+      klass.anonymous?.must_equal false
+    end
+    
+    
+    validate :api_version do
+      klass.api_version.must_equal :v2
+    end
+
+
+    validate :body do
+      klass.body?.must_equal false    
+      create_request.body?.must_equal false
+    end
+    
+    
+    validate :endpoint_type do
+      klass.endpoint_type.must_equal :public
+    end
+    
+
+    validate :headers do
+      session_data = new_session_data
+      
+      headers = { 'X-Auth-Token' => session_data[:access][:token][:id] }
+
+      request = create_request(session_data)
+
+      request.headers.must_equal headers
+    end
+    
+    
+    validate :http_method do
+      klass.http_method.must_equal :get
+    end
+
+
+    validate :optional_params do
+      klass.optional_params.must_equal [
+        :details,
+        :server,
+        :name,
+        :status,
+        'changes-since',
+        :marker,
+        :limit,
+        :type
+      ]
+    end
+
+
+    validate :required_params do
+      klass.required_params.must_equal []
+    end
+
+
+    validate :url do
+      session_data = new_session_data
+      service_spec = session_data[:access][:serviceCatalog].find{|s| s[:type] == 'compute' }
+      url          = "#{ service_spec[:endpoints][0][:publicURL] }/images"
+            
+      params = [
+        [ :details,  true                             ],
+        [ :name,    'cirros-0.3.1-x86_64-uec-ramdisk' ],
+        [ :status,  'ACTIVE'                          ],
+        [ :type,    'application/vnd.openstack.image' ]
+      ]
+
+      url += "/detail" if params.first[1]
+    
+      filters = []
+
+      params[1, params.length-1].each { |pair| filters << "#{ pair[0] }=#{ pair[1] }" }
+
+      url += "?#{ filters.join('&') }" unless filters.empty?
+      
+      request = klass.new(session_data) do |p|
+        params.each { |pair| p[pair[0]] = pair[1] }
+      end
+      
+          
+      request.url.must_equal url
+    end
+    
+    
+    validate_response 'no parameters are provided' do
+      service = Aviator::Service.new(
+        provider: 'openstack',
+        service:  'compute',
+        default_session_data: new_session_data
+      )
+      
+      response = service.request :list_images
+      
+      response.status.must_equal 200
+      response.body.wont_be_nil
+      response.headers.wont_be_nil
+    end
+    
+    
+    validate_response 'parameters are invalid' do
+      service = Aviator::Service.new(
+        provider: 'openstack',
+        service:  'compute',
+        default_session_data: new_session_data
+      )
+      
+      response = service.request :list_images do |params|
+        params[:name] = "nonexistentimagenameherpderp"
+      end
+      
+      response.status.must_equal 200
+      response.body.wont_be_nil
+      response.body[:images].length.must_equal 0
+      response.headers.wont_be_nil
+    end
+
+
+    validate_response 'parameters are valid' do
+      service = Aviator::Service.new(
+        provider: 'openstack',
+        service:  'compute',
+        default_session_data: new_session_data
+      )
+      
+      response = service.request :list_images do |params|
+        params[:details] = true
+        params[:name] = "cirros-0.3.1-x86_64-uec-ramdisk"
+      end
+      
+      response.status.must_equal 200
+      response.body.wont_be_nil
+      response.body[:images].length.must_equal 1
+      response.headers.wont_be_nil
+    end    
+
+  end
+
+end