fog 1.23.0 → 1.24.0

data/tests/google/requests/sql/operation_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('Fog::Google[:sql] | operation requests', ['google']) do
+  @sql = Fog::Google[:sql]
+  @instance_id = Fog::Mock.random_letters(16)
+  @instance = @sql.instances.create(:instance => @instance_id, :tier => 'D1')
+  @instance.wait_for { ready? }
+
+  @get_operation_format = {
+    'operation' => String,
+    'endTime' => Fog::Nullable::String,
+    'enqueuedTime' => String,
+    'error' => Fog::Nullable::Array,
+    'exportContext' => Fog::Nullable::Array,
+    'importContext' => Fog::Nullable::Array,
+    'instance' => String,
+    'kind' => String,
+    'operationType' => String,
+    'startTime' => Fog::Nullable::String,
+    'state' => String,
+    'userEmailAddress' => String,
+  }
+
+  @list_operations_format = {
+    'kind' => String,
+    'items' => [@get_operation_format],
+  }
+
+  tests('success') do
+
+    tests('#list_operations').formats(@list_operations_format) do
+      @sql.list_operations(@instance_id).body
+    end
+
+    tests('#get_operation').formats(@get_operation_format) do
+      operation_id = @sql.operations.all(@instance_id).first.operation
+      @sql.get_operation(@instance_id, operation_id).body
+    end
+
+  end
+
+  @instance.destroy
+
+end

data/tests/google/requests/sql/ssl_cert_tests.rb

@@ -0,0 +1,61 @@
+Shindo.tests('Fog::Google[:sql] | ssl_cert requests', ['google']) do
+  @sql = Fog::Google[:sql]
+  @instance_id = Fog::Mock.random_letters(16)
+  @instance = @sql.instances.create(:instance => @instance_id, :tier => 'D1')
+  @instance.wait_for { ready? }
+
+  @get_ssl_cert_format = {
+    'sha1Fingerprint' => String,
+    'cert' => String,
+    'certSerialNumber' => String,
+    'commonName' => String,
+    'createTime' => String,
+    'expirationTime' => Fog::Nullable::String,
+    'instance' => String,
+    'kind' => String,
+  }
+
+  @insert_ssl_cert_format = {
+    'kind' => String,
+    'serverCaCert' => @get_ssl_cert_format,
+    'clientCert' => {
+      'certInfo' => @get_ssl_cert_format,
+      'certPrivateKey' => String,
+    },
+  }
+
+  @list_ssl_certs_format = {
+    'kind' => String,
+    'items' => [@get_ssl_cert_format],
+  }
+
+  @delete_ssl_cert_format = {
+    'kind' => String,
+    'operation' => String,
+  }
+
+  tests('success') do
+
+    tests('#insert_ssl_cert').formats(@insert_ssl_cert_format) do
+      @sql.insert_ssl_cert(@instance_id, Fog::Mock.random_letters(16)).body
+    end
+
+    tests('#list_ssl_certs').formats(@list_ssl_certs_format) do
+      @sql.list_ssl_certs(@instance_id).body
+    end
+
+    tests('#get_ssl_cert').formats(@get_ssl_cert_format) do
+      sha1_fingerprint = @sql.ssl_certs.all(@instance_id).first.sha1_fingerprint
+      @sql.get_ssl_cert(@instance_id, sha1_fingerprint).body
+    end
+
+    tests('#delete_ssl_cert').formats(@delete_ssl_cert_format) do
+      sha1_fingerprint = @sql.ssl_certs.all(@instance_id).first.sha1_fingerprint
+      @sql.delete_ssl_cert(@instance_id, sha1_fingerprint).body
+    end
+
+  end
+
+  @instance.destroy
+
+end

data/tests/google/requests/sql/tier_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Google[:sql] | tier requests', ['google']) do
+  @sql = Fog::Google[:sql]
+
+  @get_tier_format = {
+    'tier' => String,
+    'DiskQuota' => String,
+    'kind' => String,
+    'RAM' => String,
+    'region' => Array,
+  }
+
+  @list_tiers_format = {
+    'kind' => String,
+    'items' => [@get_tier_format],
+  }
+
+  tests('success') do
+
+    tests('#list_tiers').formats(@list_tiers_format) do
+      @sql.list_tiers.body
+    end
+
+  end
+
+end

data/tests/google/requests/storage/object_tests.rb

@@ -15,7 +15,7 @@ Shindo.tests('Fog::Storage[:google] | object requests', ["google"]) do
       Fog::Storage[:google].copy_object(@directory.identity, 'fog_object', @directory.identity, 'fog_other_object')
     end
 
-    @directory.files.get('fog_other_object').destroy
+    Fog::Storage[:google].delete_object(@directory.identity, 'fog_other_object')
 
     tests("#get_object('#{@directory.identity}', 'fog_object')").returns(lorem_file.read) do
       Fog::Storage[:google].get_object(@directory.identity, 'fog_object').body

data/tests/helpers/collection_helper.rb

@@ -10,8 +10,8 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
       pending if Fog.mocking? && !mocks_implemented
       @instance = collection.create(params)
     end
-
     # FIXME: work around for timing issue on AWS describe_instances mocks
+
     if Fog.mocking? && @instance.respond_to?(:ready?)
       @instance.wait_for { ready? }
     end

data/tests/helpers/mock_helper.rb

@@ -77,6 +77,7 @@ if Fog.mock?
     :ovirt_password                   => '123123',
     :libvirt_uri                      => 'qemu://libvirt/system',
     :rackspace_api_key                => 'rackspace_api_key',
+    :rackspace_region                 => 'dfw',
     :rackspace_username               => 'rackspace_username',
     :riakcs_access_key_id             => 'riakcs_access_key_id',
     :riakcs_secret_access_key         => 'riakcs_secret_access_key',

data/tests/hp/storage_tests.rb

@@ -1,25 +1,28 @@
-Shindo.tests('Fog::Storage::HP', ['hp', 'storage']) do
-  credentials = {
-    :auth_token => 'auth_token',
-    :endpoint_url => 'http://127.0.0.1/path/',
-    :cdn_endpoint_url => 'http://127.0.0.1/cdnpath/',
-    :service_catalog => {
-      :"Object Storage" => {
-      :zone => 'http://127.0.0.1/path/'},
-      :"CDN" => {
-      :zone => 'http://127.0.0.1/cdnpath/'}},
-    :expires => (DateTime.now + 1).to_s
-  }
-  options = {
-    :hp_access_key => 'key',
-    :hp_secret_key => 'secret',
-    :hp_tenant_id => 'tenant',
-    :hp_avl_zone => 'zone',
-    :hp_auth_uri => 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/tokens',
-    :credentials => credentials
-  }
-  tests('Test cached Storage credentials').returns(credentials) do
-    conn = Fog::Storage::HP::Real.new(options)
-    conn.credentials
+unless ENV["FOG_MOCK"] == "true"
+  Shindo.tests('Fog::Storage::HP', ['hp', 'storage']) do
+    credentials = {
+      :auth_token       => 'auth_token',
+      :endpoint_url     => 'http://127.0.0.1/path/',
+      :cdn_endpoint_url => 'http://127.0.0.1/cdnpath/',
+      :service_catalog  => {
+        :"Object Storage" => {
+          :zone => 'http://127.0.0.1/path/'},
+        :"CDN"            => {
+          :zone => 'http://127.0.0.1/cdnpath/'}},
+      :expires          => (DateTime.now + 1).to_s
+    }
+    options     = {
+      :hp_access_key => 'key',
+      :hp_secret_key => 'secret',
+      :hp_tenant_id  => 'tenant',
+      :hp_avl_zone   => 'zone',
+      :hp_auth_uri   => 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/tokens',
+      :credentials   => credentials
+    }
+    tests('Test cached Storage credentials').returns(credentials) do
+
+      conn = Fog::Storage::HP::Real.new(options)
+      conn.credentials
+    end
   end
 end

data/tests/linode/requests/compute/linodeplans_tests.rb

@@ -15,7 +15,8 @@ Shindo.tests('Fog::Compute[:linode] | linodeplans requests', ['linode']) do
       'PRICE'   => Float,
       'RAM'     => Integer,
       'LABEL'   => String,
-      'XFER'    => Integer
+      'XFER'    => Integer,
+      'CORES'   => Integer
     }]
   })
 

data/tests/openstack/authenticate_tests.rb

@@ -102,6 +102,26 @@ Shindo.tests('OpenStack | authenticate', ['openstack']) do
       end
     end
 
+    tests("v2 missing storage service") do
+      Excon.stub({ :method => 'POST', :path => "/v2.0/tokens" },
+                 { :status => 200, :body => Fog::JSON.encode(body) })
+
+      raises(NoMethodError,
+            "undefined method `join' for \"object-store\":String") do
+        Fog::OpenStack.authenticate_v2(
+          :openstack_auth_uri     => URI('http://example/v2.0/tokens'),
+          :openstack_tenant       => 'admin',
+          :openstack_service_type => 'object-store')
+      end
+      raises(Fog::Errors::NotFound,
+            "Could not find service object-store.  Have compute, image") do
+        Fog::OpenStack.authenticate_v2(
+          :openstack_auth_uri     => URI('http://example/v2.0/tokens'),
+          :openstack_tenant       => 'admin',
+          :openstack_service_type => %w[object-store])
+      end
+    end
+
     tests("v2 auth with two compute services") do
       body_clone = body.clone
       body_clone["access"]["serviceCatalog"] <<

data/tests/rackspace/helper.rb

@@ -60,6 +60,19 @@ module Shindo
       sleep 30 unless Fog.mocking?
     end
 
+    def wait_for_volume_state(service, volume_id, state)
+      current_state = nil
+      until current_state == state
+        current_state = service.get_volume(volume_id).body['volume']['status']
+        if current_state == 'error'
+          Fog::Logger.warning caller
+          Fog::Logger.warning "Volume is in an error state!"
+          return
+        end
+        sleep 10 unless Fog.mocking?
+      end
+    end
+
     def rackspace_test_image_id(service)
       image_id  = Fog.credentials[:rackspace_image_id]
       # I chose to use the first Ubuntu because it will work with the smallest flavor and it doesn't require a license

data/tests/rackspace/models/databases/database_tests.rb

@@ -13,5 +13,17 @@ Shindo.tests('Fog::Rackspace::Databases | database', ['rackspace']) do
 
   model_tests(instance.databases, { :name => "db_#{Time.now.to_i.to_s}" }, false)
 
+  user_no_host = instance.users.create(:name => "foo", :password => "foo")
+  user_with_host = instance.users.create(:name => "bar", :host => "10.20.30.40", :password => "bar")
+    
+  db = instance.databases.create(:name => "Test_#{Time.now.to_i}")
+
+  db.grant_access_for(user_no_host)
+  db.grant_access_for(user_with_host)
+  
+  db.revoke_access_for(user_no_host)
+  db.revoke_access_for(user_with_host)
+    
+
   instance.destroy
 end

data/tests/rackspace/models/load_balancers/load_balancer_tests.rb

@@ -2,16 +2,29 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
 
   pending if Fog.mocking?
 
-  LOAD_BALANCER_ATTRIBUTES = {
-      :name => 'fog' + Time.now.to_i.to_s,
-      :protocol => 'HTTP',
-      :port => 80,
-      :virtual_ips => [{ :type => 'PUBLIC'}],
-      :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
-    }
+  MINIMAL_LB_ATTRIBUTES = {
+    :name => "fog#{Time.now.to_i}",
+    :protocol => 'HTTP',
+    :virtual_ips => [{ :type => 'PUBLIC' }],
+  }
+
+  NORMAL_LB_ATTRIBUTES = MINIMAL_LB_ATTRIBUTES.merge({
+    :port => 8080,
+    :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED' }]
+  })
+
+  FULL_LB_ATTRIBUTES = NORMAL_LB_ATTRIBUTES.merge({
+    :algorithm => 'LEAST_CONNECTIONS',
+    :timeout => 60
+  })
+
+  HTTPS_REDIRECT_LB_ATTRIBUTES = FULL_LB_ATTRIBUTES.merge({
+    :protocol => 'HTTPS',
+    :https_redirect => true
+  })
 
   given_a_load_balancer_service do
-    model_tests(@service.load_balancers, LOAD_BALANCER_ATTRIBUTES, false) do
+    model_tests(@service.load_balancers, NORMAL_LB_ATTRIBUTES, false) do
 
       @instance.wait_for { ready? }
       tests('#save => saving existing with port = 88').succeeds do
@@ -41,7 +54,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
         returns(false) { @instance.connection_logging }
       end
 
-   @instance.wait_for { ready? }
+      @instance.wait_for { ready? }
       tests('#enable_content_caching').succeeds do
         @instance.enable_content_caching
         returns(true) { @instance.content_caching }
@@ -169,11 +182,20 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
       @instance.wait_for { ready? }
     end
 
-    tests('create(...with algorithm...)') do
-      attributes = LOAD_BALANCER_ATTRIBUTES.clone
-      attributes[:algorithm] = 'LEAST_CONNECTIONS'
-      attributes[:timeout] = 60
-      @lb = @service.load_balancers.create attributes
+    tests('create with minimal attributes') do
+      @lb = @service.load_balancers.create MINIMAL_LB_ATTRIBUTES
+
+      returns(MINIMAL_LB_ATTRIBUTES[:name]) { @lb.name }
+      returns('HTTP') { @lb.protocol }
+      returns(80) { @lb.port }
+
+      @lb.wait_for { ready? }
+
+      @lb.destroy
+    end
+
+    tests('create with full attributes') do
+      @lb = @service.load_balancers.create FULL_LB_ATTRIBUTES
       returns('LEAST_CONNECTIONS') { @lb.algorithm }
       returns(60) { @lb.timeout }
 
@@ -182,8 +204,19 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
       @lb.destroy
     end
 
+    tests('create with httpsRedirect') do
+      @lb = @service.load_balancers.create HTTPS_REDIRECT_LB_ATTRIBUTES
+      returns('HTTPS') { @lb.protocol }
+      returns(true) { @lb.https_redirect }
+
+      @lb.wait_for { ready? }
+
+      @lb.destroy
+    end
+
+
     tests('failure') do
-      @lb = @service.load_balancers.new LOAD_BALANCER_ATTRIBUTES
+      @lb = @service.load_balancers.new NORMAL_LB_ATTRIBUTES
       tests('#usage => Requires ID').raises(ArgumentError) do
         @lb.usage
       end

data/tests/rackspace/requests/block_storage/volume_tests.rb

@@ -10,6 +10,7 @@ Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do
     'volume_type' => String,
     'availability_zone' => String,
     'snapshot_id' => Fog::Nullable::String,
+    'image_id' => Fog::Nullable::String,
     'attachments' => Array,
     'metadata' => Hash
   }
@@ -25,12 +26,23 @@ Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do
   service = Fog::Rackspace::BlockStorage.new
 
   tests('success') do
-    id = nil
+    ids = []
     size = 100
 
     tests("#create_volume(#{size})").formats(get_volume_format) do
       data = service.create_volume(size).body
-      id = data['volume']['id']
+      ids << data['volume']['id']
+      data
+    end
+
+    tests("#create_volume for a bootable volume").formats(get_volume_format) do
+      # Find a suitable image.
+      image_id = rackspace_test_image_id(Fog::Compute.new(:provider => 'rackspace'))
+      data = service.create_volume(size, :image_id => image_id).body
+      tests("assigned an image id").returns(image_id) do
+        data['volume']['image_id']
+      end
+      ids << data['volume']['id']
       data
     end
 
@@ -38,12 +50,16 @@ Shindo.tests('Fog::Rackspace::BlockStorage | volume_tests', ['rackspace']) do
       service.list_volumes.body
     end
 
-    tests("#get_volume(#{id})").formats(get_volume_format) do
-      service.get_volume(id).body
+    tests("#get_volume(#{ids.first})").formats(get_volume_format) do
+      service.get_volume(ids.first).body
     end
 
-    tests("#delete_volume(#{id})").succeeds do
-      service.delete_volume(id)
+    ids.each do |id|
+      tests("#delete_volume(#{id})").succeeds do
+        wait_for_volume_state(service, id, 'available')
+
+        service.delete_volume(id)
+      end
     end
   end
 

data/tests/rackspace/requests/compute_v2/server_tests.rb

@@ -61,6 +61,11 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
     server_name = "fog#{Time.now.to_i.to_s}"
     image_id = rackspace_test_image_id(service)
     flavor_id = rackspace_test_flavor_id(service)
+    bootable_flavor_id = if Fog.mocking?
+      flavor_id
+    else
+      service.flavors.find { |f| f.name =~ /Performance/ }.id
+    end
 
     tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(create_server_format) do
       body = service.create_server(server_name, image_id, flavor_id, 1, 1).body
@@ -69,6 +74,28 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
     end
     wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
 
+    tests("#create_server(#{server_name}_bfv_1, '', #{flavor_id}, 1, 1, :boot_volume_id => bootable_volume_id)").succeeds do
+      # First, create a bootable volume.
+      volume_service = Fog::Rackspace::BlockStorage.new
+      bootable_volume_id = volume_service.create_volume(100, :image_id => image_id).body['volume']['id']
+      wait_for_volume_state(volume_service, bootable_volume_id, 'available')
+
+      body = service.create_server(server_name + "_bfv_1", '', bootable_flavor_id, 1, 1, :boot_volume_id => bootable_volume_id).body
+      bfv_server_id = body['server']['id']
+      wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR')
+      service.delete_server(bfv_server_id)
+
+      wait_for_volume_state(volume_service, bootable_volume_id, 'available')
+      volume_service.delete_volume(bootable_volume_id)
+    end
+
+    tests("#create_server(#{server_name}_bfv_2, '', #{flavor_id}, 1, 1, :boot_image_id => #{image_id})").succeeds do
+      body = service.create_server(server_name + "_bfv_2", '', bootable_flavor_id, 1, 1, :boot_image_id => image_id).body
+      bfv_server_id = body['server']['id']
+      wait_for_server_state(service, bfv_server_id, 'ACTIVE', 'ERROR')
+      service.delete_server(bfv_server_id)
+    end
+
     tests('#list_servers').formats(list_servers_format, false) do
       service.list_servers.body
     end