aviator 0.0.5 → 0.0.6

data/test/aviator/core/request_builder_test.rb

@@ -3,9 +3,14 @@ require 'test_helper'
 class Aviator::Test
 
   describe 'aviator/core/request_builder' do
-    
+
+    def builder
+      Aviator
+    end
+
+
     describe '::define_request' do
-      
+
       it 'places the request class in the right namespace' do
         provider = :dopenstack
         service  = :supermega
@@ -13,14 +18,14 @@ class Aviator::Test
         ep_type  = :uber
         _name_   = :sample
 
-        Aviator.define_request _name_ do 
+        builder.define_request _name_ do
           meta :provider,      provider
           meta :service,       service
           meta :api_version,   api_ver
           meta :endpoint_type, ep_type
         end
         
-        [provider, service, api_ver, ep_type, _name_].inject(Aviator) do |namespace, sym|
+        [provider, service, api_ver, ep_type, _name_].inject(builder) do |namespace, sym|
           const_name = sym.to_s.camelize
           
           namespace.const_defined?(const_name, false).must_equal true
@@ -36,22 +41,138 @@ class Aviator::Test
         api_ver  = :fixnum        # This is on purpose and is critical to this test.
         ep_type  = :awesome
         _name_   = :this_request
-        
-        Aviator.define_request _name_ do 
+
+        builder.define_request _name_ do
           meta :provider,      provider
           meta :service,       service
           meta :api_version,   api_ver
           meta :endpoint_type, ep_type
         end
-        
-        [provider, service, api_ver, ep_type, _name_].inject(Aviator) do |namespace, sym|
+
+        [provider, service, api_ver, ep_type, _name_].inject(builder) do |namespace, sym|
           const_name = sym.to_s.camelize
-          
-          namespace.const_defined?(const_name, false).must_equal true, 
+
+          namespace.const_defined?(const_name, false).must_equal true,
             "Expected #{ const_name } to be defined in #{ namespace }"
-          
+
           namespace.const_get(const_name, false)
-        end   
+        end
+      end
+
+
+      it 'understands request inheritance' do
+        base = {
+          provider: :another_provider,
+          service:  :base_service,
+          api_ver:  :base_api_ver,
+          ep_type:  :base_ep_type,
+          name:     :base_name
+        }
+
+        builder.define_request base[:name] do
+          meta :provider,      base[:provider]
+          meta :service,       base[:service]
+          meta :api_version,   base[:api_ver]
+          meta :endpoint_type, base[:ep_type]
+        end
+
+        base_request = [
+          base[:provider],
+          base[:service],
+          base[:api_ver],
+          base[:ep_type],
+          base[:name]
+        ]
+
+        builder.define_request :child_request, inherit: base_request do; end
+
+        child_req_hierarchy = [
+          base[:provider],
+          base[:service],
+          base[:api_ver],
+          base[:ep_type],
+          :child_request
+        ]
+
+        child_request = child_req_hierarchy.inject(builder) do |namespace, sym|
+          namespace.const_get(sym.to_s.camelize, false)
+        end
+
+        child_request.wont_be_nil
+        child_request.provider.must_equal      base[:provider]
+        child_request.service.must_equal       base[:service]
+        child_request.api_version.must_equal   base[:api_ver]
+        child_request.endpoint_type.must_equal base[:ep_type]
+      end
+
+
+      it 'raises a BaseRequestNotFoundError if base request does not exist' do
+        non_existent_base = [:none, :existent, :base]
+
+        the_method = lambda do
+          builder.define_request :child, inherit: non_existent_base do; end
+        end
+
+        the_method.must_raise Aviator::BaseRequestNotFoundError
+
+        error = the_method.call rescue $!
+
+        error.message.wont_be_nil
+        error.base_request_hierarchy.wont_be_nil
+        error.base_request_hierarchy.must_equal non_existent_base
+      end
+
+
+      it 'raises a RequestAlreadyDefinedError if the request is already defined' do
+        request = {
+          provider: :existing_provider,
+          service:  :base_service,
+          api_ver:  :base_api_ver,
+          ep_type:  :base_ep_type,
+          name:     :base_name
+        }
+
+        builder.define_request request[:name] do
+          meta :provider,      request[:provider]
+          meta :service,       request[:service]
+          meta :api_version,   request[:api_ver]
+          meta :endpoint_type, request[:ep_type]
+        end
+
+        the_method = lambda do
+          builder.define_request request[:name] do
+            meta :provider,      request[:provider]
+            meta :service,       request[:service]
+            meta :api_version,   request[:api_ver]
+            meta :endpoint_type, request[:ep_type]
+          end
+        end
+
+        the_method.must_raise Aviator::RequestAlreadyDefinedError
+
+        error = the_method.call rescue $!
+
+        error.message.wont_be_nil
+        error.request_name.must_equal request[:name].to_s.camelize
+      end
+
+
+      it 'automatically attempts to load the base class if it\'s not yet loaded' do
+        base_arr  = [:openstack, :identity, :v2, :public, :root]
+        child_arr = base_arr.first(base_arr.length - 1) + [:child]
+
+        builder.define_request child_arr.last, inherit: base_arr do; end
+
+        base_klass = base_arr.inject(builder) do |namespace, sym|
+          namespace.const_get(sym.to_s.camelize, false)
+        end
+
+        child_klass = child_arr.inject(builder) do |namespace, sym|
+          namespace.const_get(sym.to_s.camelize, false)
+        end
+
+        base_klass.wont_be_nil
+        child_klass.wont_be_nil
       end
 
     end

data/test/aviator/core/request_test.rb

@@ -211,6 +211,70 @@ class Aviator::Test
         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
+
+
+      it 'allows aliases to be accessible as strings' 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
     
     end
     

data/test/aviator/core/service_test.rb

@@ -74,6 +74,24 @@ class Aviator::Test
       end
 
 
+      it 'raises an error if session data does not have the endpoint information' do
+        request_name = config[:auth_service][:request].to_sym
+
+        bootstrap = 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":
+          []}}}').with_indifferent_access
+          
+        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
 

data/test/aviator/openstack/common/v2/public/base_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/openstack/common/v2/public/base' do
+
+    def create_request(session_data = get_session_data, &block)
+      block ||= lambda do |params|
+                  params[:tenant_id] = 0
+                  params[:role_id]   = 0
+                  params[:user_id]   = 0
+                end
+
+      klass.new(session_data, &block)
+    end
+
+
+    def get_session_data
+      session.send :auth_info
+    end
+
+
+    def helper
+      Aviator::Test::RequestHelper
+    end
+
+
+    def klass
+      @klass ||= helper.load_request('openstack', 'common', 'v2', 'public', 'base.rb')
+    end
+
+
+    def session
+      unless @session
+        @session = Aviator::Session.new(
+          config_file: Environment.path,
+          environment: 'openstack_admin'
+        )
+        @session.authenticate
+      end
+
+      @session
+    end
+
+
+    validate_attr :anonymous? do
+      klass.anonymous?.must_equal false
+    end
+
+
+    validate_attr :api_version do
+      klass.api_version.must_equal :v2
+    end
+
+
+    validate_attr :endpoint_type do
+      klass.endpoint_type.must_equal :public
+    end
+
+
+    validate_attr :headers do
+      headers = { 'X-Auth-Token' => get_session_data[:access][:token][:id] }
+
+      request = create_request
+
+      request.headers.must_equal headers
+    end
+
+
+    describe '::base_url' do
+
+      it 'must throw a MissingServiceEndpointError when the service\'s endpoint can\'t be found' do
+        default_session_data = 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":
+          []}}}').with_indifferent_access
+
+        request = klass.new(default_session_data)
+
+        the_method = lambda { request.send(:base_url) }
+
+        the_method.must_raise Aviator::Service::MissingServiceEndpointError
+      end
+
+
+      it 'must use the base_url value if provided.' do        
+        default_session_data = 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":
+          []}}}').with_indifferent_access
+
+        base_url = 'http://sample'
+
+        default_session_data.merge!({ base_url: base_url })
+
+        request = klass.new(default_session_data)
+
+        request.send(:base_url).must_equal base_url
+      end
+
+    end
+
+  end
+
+end

data/test/aviator/openstack/compute/v2/admin/create_network_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/openstack/compute/v2/admin/create_network' do
+
+    def create_request(session_data = get_session_data, &block)
+      block ||= lambda do |p|
+        p[:label] = 'network-test'
+        p[:cidr]  = '10.0.10.0/24'
+      end
+
+      klass.new(session_data, &block)
+    end
+
+
+    def get_session_data
+      session.send :auth_info
+    end
+
+
+    def helper
+      Aviator::Test::RequestHelper
+    end
+
+
+    def klass
+      @klass ||= helper.load_request('openstack', 'compute', 'v2', 'admin', 'create_network.rb')
+    end
+
+
+    def session
+      unless @session
+        @session = Aviator::Session.new(
+          config_file: Environment.path,
+          environment: 'openstack_admin'
+        )
+        @session.authenticate
+      end
+
+      @session
+    end
+
+
+    validate_attr :anonymous? do
+      klass.anonymous?.must_equal false
+    end
+
+
+    validate_attr :api_version do
+      klass.api_version.must_equal :v2
+    end
+
+
+    validate_attr :body do
+      params = {
+        label:            'mynetwork',
+        bridge:           'dummy-value-for-test',
+        bridge_interface: 'dummy-value-for-test',
+        cidr:             'dummy-value-for-test',
+        cidr_v6:          'dummy-value-for-test',
+        dns1:             'dummy-value-for-test',
+        dns2:             'dummy-value-for-test',
+        gateway:          'dummy-value-for-test',
+        gateway_v6:       'dummy-value-for-test',
+        multi_host:       'dummy-value-for-test',
+        project_id:       'dummy-value-for-test',
+        vlan:             'dummy-value-for-test'
+      }
+
+      body = {
+        network: params
+      }
+
+      request = klass.new(helper.admin_session_data) do |p|
+        params.each do |k,v|
+          p[k] = v
+        end
+      end
+
+      request.body.must_equal body
+    end
+
+
+    validate_attr :endpoint_type do
+      klass.endpoint_type.must_equal :admin
+    end
+
+
+    validate_attr :headers do
+      headers = { 'X-Auth-Token' => get_session_data[:access][:token][:id] }
+
+      request = create_request
+
+      request.headers.must_equal headers
+    end
+
+
+    validate_attr :http_method do
+      create_request.http_method.must_equal :post
+    end
+
+
+    validate_attr :optional_params do
+      klass.optional_params.must_equal [
+        :bridge,
+        :bridge_interface,
+        :cidr,
+        :cidr_v6,
+        :dns1,
+        :dns2,
+        :gateway,
+        :gateway_v6,
+        :multi_host,
+        :project_id,
+        :vlan
+      ]
+    end
+
+
+    validate_attr :required_params do
+      klass.required_params.must_equal [:label]
+    end
+
+
+    validate_attr :url do
+      service_spec = get_session_data[:access][:serviceCatalog].find{ |s| s[:type] == 'compute' }
+      url          = "#{ service_spec[:endpoints][0][:adminURL] }/os-networks"
+
+      request = create_request
+
+      request.url.must_equal url
+    end
+
+
+    validate_response 'valid parameters are provided' do
+      response = session.compute_service.request :create_network do |params|
+        params[:label] = 'networktest'
+        params[:cidr]  = '10.0.9.0/24'
+      end
+
+      response.status.must_equal 200
+      response.body.wont_be_nil
+      response.body[:network].wont_be_nil
+      response.headers.wont_be_nil
+    end
+
+
+    validate_response 'invalid parameters are provided' do
+      response = session.compute_service.request :create_network do |params|
+        params[:label] = 'invalid-network!'
+        params[:cidr]  = 'this-is-invalid!'
+      end
+
+      response.status.must_equal 400
+      response.body.wont_be_nil
+      response.headers.wont_be_nil
+    end
+
+
+  end
+
+end

data/test/aviator/openstack/compute/v2/admin/lock_server_test.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class Aviator::Test
+
+  describe 'aviator/openstack/compute/v2/admin/lock_server' do
+
+    def create_request(session_data = get_session_data, &block)
+      block ||= lambda { |params| params[:id] = 0 }
+      klass.new(session_data, &block)
+    end
+
+
+    def get_session_data
+      session.send :auth_info
+    end
+
+
+    def helper
+      Aviator::Test::RequestHelper
+    end
+
+
+    def klass
+      @klass ||= helper.load_request('openstack', 'compute', 'v2', 'admin', 'lock_server.rb')
+    end
+
+
+    def session
+      unless @session
+        @session = Aviator::Session.new(
+                     config_file: Environment.path,
+                     environment: 'openstack_admin'
+                   )
+        @session.authenticate
+      end
+
+      @session
+    end
+
+
+    validate_attr :anonymous? do
+      klass.anonymous?.must_equal false
+    end
+
+
+    validate_attr :api_version do
+      klass.api_version.must_equal :v2
+    end
+
+
+    validate_attr :body do
+      request = create_request
+
+      klass.body?.must_equal true
+      request.body?.must_equal true
+      request.body.wont_be_nil
+    end
+
+
+    validate_attr :endpoint_type do
+      klass.endpoint_type.must_equal :admin
+    end
+
+
+    validate_attr :headers do
+      headers = { 'X-Auth-Token' => get_session_data[:access][:token][:id] }
+
+      request = create_request
+
+      request.headers.must_equal headers
+    end
+
+
+    validate_attr :http_method do
+      create_request.http_method.must_equal :post
+    end
+
+
+    validate_attr :required_params do
+      klass.required_params.must_equal [:id]
+    end
+
+
+    validate_attr :url do
+      service_spec = get_session_data[:access][:serviceCatalog].find{ |s| s[:type] == 'compute' }
+      server_id    = 'sampleId'
+      url          = "#{ service_spec[:endpoints][0][:adminURL] }/servers/#{ server_id }/action"
+
+      request = create_request do |params|
+        params[:id] = server_id
+      end
+
+      request.url.must_equal url
+    end
+
+
+    validate_response 'valid params are provided' do
+      service = session.compute_service
+      server  = service.request(:list_servers).body[:servers].first
+
+      response = service.request :lock_server do |params|
+        params[:id] = server[:id]
+      end
+
+      response.status.must_equal 202
+      response.headers.wont_be_nil
+    end
+
+
+    validate_response 'invalid server id is provided' do
+      server_id = 'abogusserveridthatdoesnotexist'
+
+      response = session.compute_service.request :lock_server do |params|
+        params[:id] = server_id
+      end
+
+      response.status.must_equal 404
+      response.body.wont_be_nil
+      response.headers.wont_be_nil
+    end
+
+
+  end
+
+end