fog 1.25.0 → 2.0.0

data/tests/glesys/requests/compute/server_tests.rb

@@ -4,11 +4,11 @@ Shindo.tests('Fog::Compute[:glesys] | server requests', ['glesys']) do
     @hostname = "fog-#{Time.now.to_i}"
 
     @create = ":hostname => #@hostname, :rootpassword => 'pw#{Time.now.to_i}', "+
-    ":datacenter => 'Falkenberg', :platform => 'Xen', :templatename => 'Debian-6 x64', "+
+    ":datacenter => 'Falkenberg', :platform => 'VMware', :templatename => 'Debian 7.0 64-bit', "+
     ":disksize => '10', :memorysize => '512', :cpucores => '1', :transfer => '500', :bandwidth => '10'"
 
     @create_vz = ":hostname => #@hostname, :rootpassword => 'pw#{Time.now.to_i}', "+
-    ":datacenter => 'Stockholm', :platform => 'OpenVZ', :templatename => 'Debian 6.0 64-bit', "+
+    ":datacenter => 'Stockholm', :platform => 'OpenVZ', :templatename => 'Debian 7.0 64-bit', "+
     ":disksize => '10', :memorysize => '256', :cpucores => '2', :transfer => '500', :bandwidth => '10'"
 
   tests('success') do
@@ -22,10 +22,11 @@ Shindo.tests('Fog::Compute[:glesys] | server requests', ['glesys']) do
       pending if Fog.mocking?
       vm =  Fog::Compute[:glesys].create(
               :hostname     => @hostname,
+              :description  => "Fog test server",
               :rootpassword => "pw#{Time.now.to_i}",
               :datacenter   => "Falkenberg",
-              :platform     => "Xen",
-              :templatename => "Debian-6 x64",
+              :platform     => "VMware",
+              :templatename => "Debian 7.0 64-bit",
               :disksize     => "10",
               :memorysize   => "512",
               :cpucores     => "1",
@@ -86,18 +87,33 @@ Shindo.tests('Fog::Compute[:glesys] | server requests', ['glesys']) do
               :rootpassword => "pw#{Time.now.to_i}",
               :datacenter   => "Stockholm",
               :platform     => "OpenVZ",
-              :templatename => "Debian 6.0 64-bit",
+              :templatename => "Debian 7.0 64-bit",
               :disksize     => "10",
               :memorysize   => "256",
               :cpucores     => "2",
               :transfer     => "500",
               :bandwidth    => "10"
             )
-
       @serverid = vm.body['response']['server']['serverid']
       vm.body['response']
     end
 
+    unless Fog.mocking?
+      Fog::Compute[:glesys].servers.get(@serverid).wait_for { ready? }
+    end
+
+    tests("#edit #{@serverid}").formats(Glesys::Compute::Formats::Servers::EDIT) do
+      pending if Fog.mocking?
+      vm = Fog::Compute[:glesys].edit(
+        :serverid => @serverid,
+        :disksize => "10",
+        :memorysize => "512",
+        :cpucores => "1",
+        :bandwidth => "10"
+      )
+      vm.body['response']
+    end
+
     tests("#server_details(#{@serverid})").formats(Glesys::Compute::Formats::Servers::DETAILS) do
       pending if Fog.mocking?
       Fog::Compute[:glesys].server_details(@serverid).body['response']

data/tests/glesys/requests/compute/ssh_key_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests("Fog::Compute[:glesys] | ssh_key requests", ["glesys", "compute"]) do
+  @testdescription = "My test key to be removed"
+  @testdata = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDv+r/dCIDv+YazWsyc1WCixR+iOeaswTx1U45h6vh4/ fog-unittest@GleSYS"
+  @testdata_malformed = "ssh-rot13 AAAAthis_is_not_an_ssh_key fog-unittest@GleSYS"
+
+  tests("success") do
+    tests("#ssh_key_add").formats(Glesys::Compute::Formats::SshKeys::ADD) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_add(:description => @testdescription, :sshkey => @testdata)
+      @resp.body["response"]
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].ssh_keys.destroy(@resp.body["response"]["sshkey"]["id"])
+      @key = Fog::Compute[:glesys].ssh_keys.create(:description => @testdescription, :data => @testdata)
+    end
+
+    tests("#ssh_key_list").formats(Glesys::Compute::Formats::SshKeys::LIST) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_list
+      @resp.body["response"]
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:glesys].ssh_keys.destroy(@key.id)
+      @key = Fog::Compute[:glesys].ssh_keys.create(:description => @testdescription, :data => @testdata)
+    end
+
+    tests("#ssh_key_remove").formats(Glesys::Compute::Formats::SshKeys::REMOVE) do
+      pending if Fog.mocking?
+      @resp = Fog::Compute[:glesys].ssh_key_remove(:sshkeyids => @key.id)
+      @resp.body["response"]
+    end
+  end
+
+  tests("failure") do
+    tests("#ssh_key_add with malformed key data").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].ssh_key_add(:description => @testdescription, :data => @testdata_malformed)
+    end
+
+    tests("#ssh_key_remove with nonexistent/invalid key id").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:glesys].ssh_key_remove(:id => -1)
+    end
+  end
+end

data/tests/helper.rb

@@ -3,6 +3,7 @@ ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
 
 require 'fog'
 require 'fog/bin' # for available_providers and registered_providers
+require 'ostruct'
 
 Excon.defaults.merge!(:debug_request => true, :debug_response => true)
 
@@ -13,6 +14,11 @@ if Fog.mocking?
   FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
   Fog.timeout = 2000
   Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+
+  # These sets of tests do not behave nicely when running mocked tests
+  Thread.current[:tags] << '-xenserver'
+  Thread.current[:tags] << '-joyent'
+  Thread.current[:tags] << '-dreamhost'
 else
   FOG_TESTING_TIMEOUT = Fog.timeout
 end
@@ -29,27 +35,18 @@ end
 all_providers = Fog.registered_providers.map {|provider| provider.downcase}
 
 # Manually remove these providers since they are local applications, not lacking credentials
-all_providers = all_providers - ["libvirt", "openvz"]
+all_providers = all_providers - ["openvz"]
 
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 
 unavailable_providers = all_providers - available_providers
 
 if !ENV['PROVIDER'].nil? && unavailable_providers.include?(ENV['PROVIDER'])
-  Formatador.display_line("[red]Requested provider #{ENV['PROVIDER']} is not available.[/]" +
+  Fog::Formatador.display_line("[red]Requested provider #{ENV['PROVIDER']} is not available.[/]" +
                           "[red]Check if .fog file has correct configuration (see '#{Fog.credentials_path}')[/]")
   exit(0)
 end
 
 for provider in unavailable_providers
-  Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '#{Fog.credentials_path}' to run them)[/]")
-  Thread.current[:tags] << ('-' << provider)
-end
-
-# mark libvirt tests pending if not setup
-begin
-  require('libvirt')
-rescue LoadError
-  Formatador.display_line("[yellow]Skipping tests for [bold]libvirt[/] [yellow]due to missing `ruby-libvirt` gem.[/]")
-  Thread.current[:tags] << '-libvirt'
+  Fog::Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '#{Fog.credentials_path}' to run them)[/]")
 end

data/tests/helpers/collection_helper.rb

@@ -39,12 +39,6 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
         'none?', 'one?'
       ]
 
-      # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep
-      # https://github.com/jruby/jruby/issues/1265
-      if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/
-        methods.delete('all?')
-      end
-
       methods.each do |enum_method|
         if collection.respond_to?(enum_method)
           tests("##{enum_method}").succeeds do

data/tests/helpers/mock_helper.rb

@@ -13,9 +13,6 @@ if Fog.mock?
     :aws_secret_access_key            => 'aws_secret_access_key',
     :ia_access_key_id                 => 'aws_access_key_id',
     :ia_secret_access_key             => 'aws_secret_access_key',
-    :atmos_storage_token              => 'atmos_token',
-    :atmos_storage_secret             => 'atmos_secret',
-    :atmos_storage_endpoint           => 'http://atmos.is.cool:1000/test1.0',
     :bluebox_api_key                  => 'bluebox_api_key',
     :bluebox_customer_id              => 'bluebox_customer_id',
     :brightbox_client_id              => 'brightbox_client_id',
@@ -26,43 +23,32 @@ if Fog.mock?
     :cloudstack_service_offering_id   => '4437ac6c-9fe3-477a-57ec-60a5a45896a4',
     :cloudstack_template_id           => '8a31cf9c-f248-0588-256e-9dbf58785216',
     :cloudstack_zone_id               => 'c554c592-e09c-9df5-7688-4a32754a4305',
+    :cloudstack_project_id            => 'f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1f1',
     :clodo_api_key                    => 'clodo_api_key',
     :clodo_username                   => 'clodo_username',
     :digitalocean_api_key             => 'digitalocean_api_key',
     :digitalocean_client_id           => 'digitalocean_client_id',
+    :digitalocean_token               => 'digitalocean_token',
     :dnsimple_email                   => 'dnsimple_email',
     :dnsimple_password                => 'dnsimple_password',
     :dnsmadeeasy_api_key              => 'dnsmadeeasy_api_key',
     :dnsmadeeasy_secret_key           => 'dnsmadeeasy_secret_key',
-    :ecloud_username                  => 'ecloud_username',
-    :ecloud_password                  => 'ecloud_password',
-    :ecloud_versions_uri              => 'http://ecloud.versions.uri',
     :glesys_username                  => 'glesys_username',
     :glesys_api_key                   => 'glesys_api_key',
     :go_grid_api_key                  => 'go_grid_api_key',
     :go_grid_shared_secret            => 'go_grid_shared_secret',
-    :google_storage_access_key_id     => 'google_storage_access_key_id',
-    :google_storage_secret_access_key => 'google_storage_secret_access_key',
-    :google_project                   => 'google_project_name',
-    :google_client_email              => 'fake@developer.gserviceaccount.com',
-    :google_key_location              => '~/fake.p12',
     :hp_access_key                    => 'hp_access_key',
     :hp_secret_key                    => 'hp_secret_key',
     :hp_tenant_id                     => 'hp_tenant_id',
     :hp_avl_zone                      => 'hp_avl_zone',
+    :hp_auth_uri                      => 'http://hp/v2.0/tokens',
     :os_account_meta_temp_url_key     => 'os_account_meta_temp_url_key',
     :ibm_username                     => 'ibm_username',
     :ibm_password                     => 'ibm_password',
-    :joyent_username                  => "joyentuser",
-    :joyent_password                  => "joyentpass",
     :linode_api_key                   => 'linode_api_key',
     :local_root                       => '~/.fog',
     :bare_metal_cloud_password        => 'bare_metal_cloud_password',
     :bare_metal_cloud_username        => 'bare_metal_cloud_username',
-    :ninefold_compute_key             => 'ninefold_compute_key',
-    :ninefold_compute_secret          => 'ninefold_compute_secret',
-    :ninefold_storage_secret          => 'ninefold_storage_secret',
-    :ninefold_storage_token           => 'ninefold_storage_token',
 #    :public_key_path                  => '~/.ssh/id_rsa.pub',
 #    :private_key_path                 => '~/.ssh/id_rsa',
     :opennebula_endpoint              => 'http://opennebula:2633/RPC2',
@@ -72,39 +58,22 @@ if Fog.mock?
     :openstack_username               => 'openstack_username',
     :openstack_tenant                 => 'openstack_tenant',
     :openstack_auth_url               => 'http://openstack:35357/v2.0/tokens',
-    :ovirt_url                        => 'http://ovirt:8080/api',
-    :ovirt_username                   => 'admin@internal',
-    :ovirt_password                   => '123123',
     :profitbricks_username            => 'profitbricks_username',
     :profitbricks_password            => 'profitbricks_password',
-    :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',
     :sakuracloud_api_token            => 'sakuracloud_api_token',
     :sakuracloud_api_token_secret     => 'sakuracloud_api_token_secret',
-    :storm_on_demand_username         => 'storm_on_demand_username',
-    :storm_on_demand_password         => 'storm_on_demand_password',
     :vcloud_host                      => 'vcloud_host',
     :vcloud_password                  => 'vcloud_password',
     :vcloud_username                  => 'vcloud_username',
     :vcloud_director_host             => 'vcloud-director-host',
     :vcloud_director_password         => 'vcloud_director_password',
     :vcloud_director_username         => 'vcd_user@vcd_org_name',
-    :zerigo_email                     => 'zerigo_email',
-    :zerigo_token                     => 'zerigo_token',
     :dynect_customer                  => 'dynect_customer',
     :dynect_username                  => 'dynect_username',
     :dynect_password                  => 'dynect_password',
-    :vsphere_server                   => 'virtualcenter.lan',
-    :vsphere_username                 => 'apiuser',
-    :vsphere_password                 => 'apipassword',
-    :vsphere_expected_pubkey_hash     => 'abcdef1234567890',
-    :libvirt_uri                      => 'qemu:///system',
-    :libvirt_username                 => 'root',
-    :libvirt_password                 => 'password',
     :cloudsigma_username              => 'csuname',
     :cloudsigma_password              => 'cspass',
     :docker_username                  => 'docker-fan',

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

@@ -3,7 +3,8 @@ Shindo.tests('Fog::Compute[:linode] | datacenter requests', ['linode']) do
   @datacenters_format = Linode::Compute::Formats::BASIC.merge({
     'DATA' => [{
       'DATACENTERID'  => Integer,
-      'LOCATION'      => String
+      'LOCATION'      => String,
+      'ABBR'          => String
     }]
   })
 

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

@@ -4,24 +4,16 @@ Shindo.tests('Fog::Compute[:linode] | kernel requests', ['linode']) do
     'DATA' => [{
       'LABEL'               => String,
       'ISXEN'               => Integer,
+      'ISKVM'               => Integer,
       'ISPVOPS'             => Integer,
       'KERNELID'            => Integer
     }]
   })
 
   tests('success') do
-    @kernel_id = nil
-
     tests('#avail_kernels').formats(@kernels_format) do
       pending if Fog.mocking?
-      data = Fog::Compute[:linode].avail_kernels.body
-      @kernel_id = data['DATA'].first['KERNELID']
-      data
-    end
-
-    tests("@avail_kernels(#{@kernel_id})").formats(@kernels_format) do
-      pending if Fog.mocking?
-      Fog::Compute[:linode].avail_kernels(@kernel_id).body
+      Fog::Compute[:linode].avail_kernels.body
     end
   end
 end

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

@@ -36,7 +36,7 @@ Shindo.tests('Fog::Compute[:linode] | linode requests', ['linode']) do
   })
 
   @ip_format = Linode::Compute::Formats::BASIC.merge({
-    'DATA' => { 'IPAddressID' => Integer }
+    'DATA' => { 'IPADDRESSID' => Integer, 'IPADDRESS' => String }
   })
 
   @disks_format = Linode::Compute::Formats::BASIC.merge({
@@ -53,10 +53,42 @@ Shindo.tests('Fog::Compute[:linode] | linode requests', ['linode']) do
     }]
   })
 
+  @images_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{
+      "LAST_USED_DT" => String,
+      "DESCRIPTION"  => String,
+      "LABEL"        => String,
+      "STATUS"       => String,
+      "TYPE"         => String,
+      "MINSIZE"      => Integer,
+      "ISPUBLIC"     => Integer,
+      "CREATE_DT"    => String,
+      "FS_TYPE"      => String,
+      "CREATOR"       => String,
+      "IMAGEID"      => Integer
+    }]
+  })
+
   @disk_format = Linode::Compute::Formats::BASIC.merge({
     'DATA' => { 'JobID' => Integer, 'DiskID' => Integer }
   })
 
+  @disk_createfromimage_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'JOBID' => Integer, 'DISKID' => Integer }
+  })
+
+  @disk_resize_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'JobID' => Integer }
+  })
+
+  @disk_imagize_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'JobID' => Integer, 'ImageID' => Integer }
+  })
+
+  @disk_update_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'DiskID' => Integer }
+  })
+
   tests('success') do
 
     @linode_id = nil
@@ -81,7 +113,8 @@ Shindo.tests('Fog::Compute[:linode] | linode requests', ['linode']) do
 
     tests('#linode_update').formats(@linode_format) do
       pending if Fog.mocking?
-      Fog::Compute[:linode].linode_update(@linode_id, :label => 'testing').body
+      rand_label = 'testing' + Fog::Mock.random_letters(6)
+      Fog::Compute[:linode].linode_update(@linode_id, :label => rand_label).body
     end
 
     tests('#linode_ip_addprivate').formats(@ip_format) do
@@ -96,13 +129,47 @@ Shindo.tests('Fog::Compute[:linode] | linode requests', ['linode']) do
       data
     end
 
+    tests('#linode_disk_update').formats(@disk_update_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:linode].linode_disk_update(@linode_id, @disk1_id, 'test1-updated', 1).body
+    end
+
+    tests('#linode_disk_duplicate').formats(@disk_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:linode].linode_disk_duplicate(@linode_id, @disk1_id).body
+    end
+
+    tests('#linode_disk_resize').formats(@disk_resize_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:linode].linode_disk_resize(@linode_id, @disk1_id, 2).body
+    end
+
+    tests('#linode_disk_imagize').formats(@disk_imagize_format) do
+      pending if Fog.mocking?
+      data = Fog::Compute[:linode].linode_disk_imagize(@linode_id, @disk1_id, 'test description imageid1', 'test label imageid1').body
+      @image1_id = data['DATA']['ImageID']
+      data
+    end
+
     tests('#linode_disk_createfromdistribution').formats(@disk_format) do
       pending if Fog.mocking?
-      data = Fog::Compute[:linode].linode_disk_createfromdistribution(@linode_id, 73, 'test1', 600, 'P@SSW)RD').body
+      data = Fog::Compute[:linode].linode_disk_createfromdistribution(@linode_id, 124, 'test1', 750, 'P@SSW)RD').body
       @disk2_id = data['DATA']['DiskID']
       data
     end
 
+    tests('#linode_disk_createfromimage').formats(@disk_createfromimage_format) do
+      pending if Fog.mocking?
+      data = Fog::Compute[:linode].linode_disk_createfromimage(@linode_id, @image1_id, 'test1', 3, 'P@SSW)RD', '').body
+      @disk3_id = data['DATA']['DISKID']
+      data
+    end
+
+    tests('#image_list').formats(@images_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:linode].image_list(@image_id).body
+    end
+
     tests('#linode_disk_list').formats(@disks_format) do
       pending if Fog.mocking?
       Fog::Compute[:linode].linode_disk_list(@linode_id).body
@@ -112,10 +179,16 @@ Shindo.tests('Fog::Compute[:linode] | linode requests', ['linode']) do
     #   Fog::Compute[:linode].linode_reboot(@linode_id).body
     # end
 
+    tests('#image_delete').formats(@images_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:linode].image_delete(@image1_id).body
+    end
+
     tests('#linode_disk_delete').formats(@disk_format) do
       pending if Fog.mocking?
       Fog::Compute[:linode].linode_disk_delete(@linode_id, @disk1_id).body
       Fog::Compute[:linode].linode_disk_delete(@linode_id, @disk2_id).body
+      Fog::Compute[:linode].linode_disk_delete(@linode_id, @disk3_id).body
     end
 
     tests('#linode_delete(#{@linode_id})').succeeds do

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

@@ -3,12 +3,14 @@ Shindo.tests('Fog::Compute[:linode] | linodeplans requests', ['linode']) do
   @linodeplans_format = Linode::Compute::Formats::BASIC.merge({
     'DATA' => [{
       'AVAIL' => {
-         '2' => Integer,
-         '3' => Integer,
-         '4' => Integer,
-         '6' => Integer,
-         '7' => Integer,
-         '8' => Integer
+         '2'  => Integer,
+         '3'  => Integer,
+         '4'  => Integer,
+         '6'  => Integer,
+         '7'  => Integer,
+         '8'  => Integer,
+         '9'  => Integer,
+         '10' => Integer
       },
       'DISK'    => Integer,
       'PLANID'  => Integer,
@@ -16,7 +18,8 @@ Shindo.tests('Fog::Compute[:linode] | linodeplans requests', ['linode']) do
       'RAM'     => Integer,
       'LABEL'   => String,
       'XFER'    => Integer,
-      'CORES'   => Integer
+      'CORES'   => Integer,
+      'HOURLY'  => Float
     }]
   })