fog 0.8.1 → 0.8.2

data/spec/ecloud/spec_helper.rb

@@ -253,7 +253,7 @@ end
 
 Spec::Runner.configure do |config|
   config.after(:all) do
-    Fog::Ecloud::Compute::Mock.data_reset
+    Fog::Ecloud::Compute::Mock.reset
   end
 
   config.before(:each, :type => :vcloud_request) do
@@ -261,12 +261,12 @@ Spec::Runner.configure do |config|
   end
 
   config.before(:each, :type => :mock_tmrk_ecloud_request) do
-    Fog::Ecloud::Compute::Mock.data_reset
+    Fog::Ecloud::Compute::Mock.reset
     setup_ecloud_mock_data
     @vcloud = Fog::Ecloud::Compute.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_model) do
-    Fog::Ecloud::Compute::Mock.data_reset
+    Fog::Ecloud::Compute::Mock.reset
     setup_ecloud_mock_data
     @vcloud = Fog::Ecloud::Compute.new(:ecloud_username => "foo", :ecloud_password => "bar", :ecloud_versions_uri => "http://fakey.com/api/versions")
   end

data/tests/compute/helper.rb

@@ -1,9 +1,7 @@
 def compute_providers
   {
     AWS       => {
-      :server_attributes => {
-        :image_id => 'ami-1a837773' # image ami-1a837773 = Ubuntu
-      },
+      :server_attributes => {},
       :mocked => true
     },
     Bluebox   => {

data/tests/compute/models/aws/server_tests.rb

@@ -1,10 +1,11 @@
 Shindo.tests("AWS::Compute | monitor", ['aws']) do
 
-  [:addresses, :flavor, :key_pair, :key_pair=, :volume].each do |association|
+  @instance = AWS[:compute].servers.new
+
+  [:addresses, :flavor, :key_pair, :key_pair=, :volumes].each do |association|
     responds_to(association)
   end
 
-  @instance = AWS[:compute].servers.new
 
   tests('new instance') do
 

data/tests/compute/requests/aws/instance_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('AWS::Compute | instance requests', ['aws']) do
     # 'architecture'    => String,
     'amiLaunchIndex'      => Integer,
     'blockDeviceMapping'  => [],
-    'clientToken'         => NilClass,
+    'clientToken'         => Fog::Nullable::String,
     'dnsName'             => NilClass,
     'imageId'             => String,
     'instanceId'          => String,
@@ -60,7 +60,7 @@ Shindo.tests('AWS::Compute | instance requests', ['aws']) do
 
   @get_password_data_format = {
     'instanceId'   => String,
-    'passwordData' => String,
+    'passwordData' => Fog::Nullable::String,
     'requestId'    => String,
     'timestamp'    => Time
   }
@@ -119,15 +119,18 @@ Shindo.tests('AWS::Compute | instance requests', ['aws']) do
     end
 
     tests("#get_password_data('#{@instance_id}')").formats(@get_password_data_format) do
-      pending if Fog.mock?
-      result = nil
-      Fog.wait_for do
-         result = AWS[:compute].get_password_data(@instance_id).body
-         !result['passwordData'].nil?
-      end
+      result = AWS[:compute].get_password_data(@instance_id).body
 
       tests("key can decrypt passwordData").returns(true) do
-        decoded_password = Base64.decode64(result['passwordData'])
+
+        pending if Fog.mocking?
+
+        password_data = result['passwordData']
+        Fog.wait_for do
+          password_data ||= AWS[:compute].get_password_data(@instance_id).body['passwordData']
+        end
+
+        decoded_password = Base64.decode64(password_data)
         pkey = OpenSSL::PKey::RSA.new(key.private_key)
         String === pkey.private_decrypt(decoded_password)
       end

data/tests/compute/requests/aws/key_pair_tests.rb

@@ -21,7 +21,7 @@ Shindo.tests('AWS::Compute | key pair requests', ['aws']) do
 
     tests("#create_key_pair('#{@key_pair_name}')").formats(@keypair_format.merge({'keyMaterial' => String})) do
       body = AWS[:compute].create_key_pair(@key_pair_name).body
-      tests("private key is valid RSA key").returns(OpenSSL::PKey::RSA) do
+      tests("key material").returns(OpenSSL::PKey::RSA, "is a valid private RSA key") do
         OpenSSL::PKey::RSA.new(body['keyMaterial']).class
       end
       body

data/tests/compute/requests/aws/volume_tests.rb

@@ -22,12 +22,12 @@ Shindo.tests('AWS::Compute | volume requests', ['aws']) do
   @volumes_format = {
     'volumeSet' => [{
       'availabilityZone'  => String,
-      'attachmentSet'     => [],
+      'attachmentSet'     => Array,
       'createTime'        => Time,
       'size'              => Integer,
       'snapshotId'        => Fog::Nullable::String,
       'status'            => String,
-      'tagSet'            => {},
+      'tagSet'            => Hash,
       'volumeId'          => String
     }],
     'requestId' => String

data/tests/compute/requests/brightbox/helper.rb

@@ -270,6 +270,9 @@ class Brightbox
           "library_ftp_host" => String,
           "library_ftp_user" => String,
           "library_ftp_password" => Fog::Nullable::String,
+          "verified_telephone" => Fog::Nullable::Boolean,
+          "verified_at"     => Fog::Nullable::Time,
+          "verified_ip"     => Fog::Nullable::String,
           "owner"           => Brightbox::Compute::Formats::Nested::USER,
           "users"           => [Brightbox::Compute::Formats::Nested::USER],
           "clients"         => [Brightbox::Compute::Formats::Nested::API_CLIENT],

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

@@ -0,0 +1,27 @@
+Shindo.tests('Linode::Compute | kernel requests', ['linode']) do
+
+  @kernels_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{ 
+      'LABEL'               => String,
+      'ISXEN'               => Integer,
+      'ISPVOPS'             => Integer,
+      'KERNELID'            => Integer
+    }]
+  })
+
+  tests('success') do
+    @kernel_id = nil
+
+    tests('#avail_kernels').formats(@kernels_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].avail_kernels.body
+      @kernel_id = data['DATA'].first['KERNELID']
+      data
+    end
+
+    tests("@avail_kernels(#{@kernel_id})").formats(@kernels_format) do
+      pending if Fog.mocking?
+      Linode[:compute].avail_kernels(@kernel_id).body
+    end
+  end
+end

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

@@ -35,6 +35,28 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
     'DATA' => { 'JobID' => Integer }
   })
 
+  @ip_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'IPAddressID' => Integer }
+  })
+
+  @disks_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{
+      "UPDATE_DT"  => String,
+      "DISKID"     => Integer,
+      "LABEL"      => String,
+      "TYPE"       => String,
+      "LINODEID"   => Integer,
+      "ISREADONLY" => Integer,
+      "STATUS"     => Integer,
+      "CREATE_DT"  => String,
+      "SIZE"       => Integer
+    }]
+  })
+
+  @disk_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'JobID' => Integer, 'DiskID' => Integer }
+  })  
+
   tests('success') do
 
     @linode_id = nil
@@ -53,16 +75,52 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
     end
 
     tests('#linode_list').formats(@linodes_format) do
-      pending if Fog.mocking?
+      pending if Fog.mocking?      
       Linode[:compute].linode_list.body
     end
 
+    tests('#linode_update').formats(@linode_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_update(@linode_id, :label => 'testing').body
+    end
+
+    tests('#linode_ip_addprivate').formats(@ip_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_ip_addprivate(@linode_id).body
+    end
+
+    tests('#linode_disk_create').formats(@disk_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].linode_disk_create(@linode_id, 'test1', 'ext3', 1).body
+      @disk1_id = data['DATA']['DiskID']
+      data
+    end    
+
+    tests('#linode_disk_createfromdistribution').formats(@disk_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].linode_disk_createfromdistribution(@linode_id, 73, 'test1', 600, 'P@SSW)RD').body
+      @disk2_id = data['DATA']['DiskID']
+      data
+    end
+
+    tests('#linode_disk_list').formats(@disks_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_disk_list(@linode_id).body
+    end
+
     # tests("#linode_reboot(#{@linode_id})").formats(@reboot_format) do
     #   Linode[:compute].linode_reboot(@linode_id).body
-    # end
+    # end    
+
+    tests('#linode_disk_delete').formats(@disk_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_disk_delete(@linode_id, @disk1_id).body
+      Linode[:compute].linode_disk_delete(@linode_id, @disk2_id).body
+    end
 
     tests('#linode_delete(#{@linode_id})').succeeds do
       pending if Fog.mocking?
+      sleep 1 until Linode[:compute].linode_disk_list(@linode_id).body['DATA'].size == 0
       Linode[:compute].linode_delete(@linode_id)
     end
 
@@ -72,12 +130,12 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
 
     tests('#linode_reboot(0)').raises(Fog::Linode::Compute::NotFound) do
       pending if Fog.mocking?
-      Linode[:compute].linode_reboot(0)
+      Linode[:compute].linode_reboot(1)
     end
 
     tests('#linode_delete(0)').raises(Fog::Linode::Compute::NotFound) do
       pending if Fog.mocking?
-      Linode[:compute].linode_delete(0)
+      Linode[:compute].linode_delete(1)
     end
 
   end

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

@@ -0,0 +1,35 @@
+Shindo.tests('Linode::Compute | stack_script requests', ['linode']) do
+
+  @stack_scripts_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{ 
+      'STACKSCRIPTID'       => Integer,
+      'SCRIPT'              => String,
+      'DESCRIPTION'         => String,
+      'DISTRIBUTIONIDLIST'  => String,
+      'LABEL'               => String,
+      'DEPLOYMENTSTOTAL'    => Integer,
+      'LATESTREV'           => Integer,
+      'CREATE_DT'           => String,
+      'DEPLOYMENTSACTIVE'   => Integer,
+      'REV_NOTE'            => String,
+      'REV_DT'              => String,
+      'ISPUBLIC'            => Integer,
+      'USERID'              => Integer
+    }]
+  })  
+
+  tests('success') do
+
+    tests('#avail_stackscripts').formats(@stack_scripts_format) do
+      pending if Fog.mocking?
+      Linode[:compute].avail_stackscripts.body
+    end    
+    
+    tests('#stackscript_list').formats(@stack_scripts_format) do
+      pending if Fog.mocking?
+      Linode[:compute].stackscript_list.body
+    end
+
+  end
+
+end

data/tests/compute/requests/rackspace/resize_tests.rb

@@ -14,12 +14,12 @@ Shindo.tests('Rackspace::Compute | resize request', ['rackspace']) do
       Rackspace[:compute].resize_server(@revert_server.id, 2)
     end
 
-    @confirm_server.wait_for { status == 'VERIFY_RESIZE' }
+    @confirm_server.wait_for { state == 'VERIFY_RESIZE' }
     tests("#confirm_resized_server(#{@confirm_server.id})").succeeds do
       Rackspace[:compute].confirm_resized_server(@confirm_server.id)
     end
 
-    @revert_server.wait_for { status == 'VERIFY_RESIZE' }
+    @revert_server.wait_for { state == 'VERIFY_RESIZE' }
     tests("#revert_resized_server(#{@revert_server.id})").succeeds do
       Rackspace[:compute].revert_resized_server(@revert_server.id)
     end

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

@@ -34,6 +34,7 @@ Shindo.tests('Voxel::Compute | server requests', ['voxel']) do
           'id'    => String,
           'value' => String
         },
+        'position'  => Fog::Nullable::Integer,
         'rack'      => {
           'id'    => String,
           'value' => String

data/tests/core/credential_tests.rb

@@ -21,12 +21,17 @@ Shindo.tests do
       Fog.credentials_path
     }
 
-    returns('/home/me/.fog', 'falls back to home path if FOG_RC not set') {
-      ENV['HOME'] = '/home/me'
+    returns(File.join(ENV['HOME'], '.fog'), 'falls back to home path if FOG_RC not set') {
       ENV.delete('FOG_RC')
       Fog.credentials_path
     }
 
+    returns(nil, 'ignores home path if it does not exist') {
+      ENV.delete('FOG_RC')
+      ENV['HOME'] = '/no/such/path'
+      Fog.credentials_path
+    }
+
     returns(nil, 'returns nil when neither FOG_RC or HOME are set') {
       ENV.delete('HOME')
       ENV.delete('FOG_RC')

data/tests/core/parser_tests.rb

@@ -59,7 +59,7 @@ posuere eu odio. Donec sodales, ante porta condimentum
   }
 
 
-  tests('TestParser').returns(@response) do
+  tests('TestParser').returns(@response, "returns the response") do
     test_parser = TestParser.new
     Nokogiri::XML::SAX::Parser.new(test_parser).parse(@xml)
     test_parser.response

data/tests/helper.rb

@@ -9,7 +9,7 @@ end
 
 # check to see which credentials are available and add others to the skipped tags list
 all_providers = ['aws', 'bluebox', 'brightbox', 'dnsimple', 'ecloud', 'gogrid', 'google', 'linode', 'local', 'newservers', 'rackspace', 'slicehost', 'stormondemand', 'voxel', 'zerigo']
-available_providers = Fog.providers.map {|provider| provider.downcase}
+available_providers = Fog.available_providers.map {|provider| provider.downcase}
 for provider in (all_providers - available_providers)
   Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '~/.fog' to run them)[/]")
   Thread.current[:tags] << ('-' << provider)

data/tests/helpers/compute/server_helper.rb

@@ -2,6 +2,12 @@ def server_tests(connection, params = {}, mocks_implemented = true)
 
   model_tests(connection.servers, params, mocks_implemented) do
 
+    tests('#reload').returns(true) do
+      pending if Fog.mocking? && !mocks_implemented
+      identity = @instance.identity
+      !identity.nil? && identity == @instance.reload.identity
+    end
+
     responds_to([:ready?, :state])
 
     tests('#reboot').succeeds do

data/tests/helpers/formats_helper.rb

@@ -4,12 +4,14 @@
 module Fog
   module Boolean; end
   module Nullable
+    module Boolean; end
     module Integer; end
     module String; end
     module Time; end
   end
 end
 [FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
+[NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
 [NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
 [NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
 [Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}

data/tests/helpers/mock_helper.rb

@@ -15,12 +15,17 @@ if Fog.mock?
     :bluebox_customer_id              => 'bluebox_customer_id',
     :brightbox_client_id              => 'brightbox_client_id',
     :brightbox_secret                 => 'brightbox_secret',
+    :dnsimple_email                   => 'dnsimple_email',
+    :dnsimple_password                => 'dnsimple_password',
+    :ecloud_username                  => 'ecloud_username',
+    :ecloud_password                  => 'ecloud_password',
+    :ecloud_versions_uri              => 'http://ecloud.versions.uri',
     :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',
     :linode_api_key                   => 'linode_api_key',
-#    :local_root                       => '~/.fog'
+    :local_root                       => '~/.fog',
     :new_servers_password             => 'new_servers_password',
     :new_servers_username             => 'new_servers_username',
 #    :public_key_path                  => '~/.ssh/id_rsa.pub',
@@ -28,6 +33,8 @@ if Fog.mock?
     :rackspace_api_key                => 'rackspace_api_key',
     :rackspace_username               => 'rackspace_username',
     :slicehost_password               => 'slicehost_password',
+    :storm_on_demand_username         => 'storm_on_demand_username',
+    :storm_on_demand_password         => 'storm_on_demand_password',
     :voxel_api_key                    => 'voxel_api_key',
     :voxel_api_secret                 => 'voxel_api_secret',
     :zerigo_email                     => 'zerigo_email',

data/tests/helpers/model_helper.rb

@@ -2,9 +2,7 @@ def model_tests(collection, params = {}, mocks_implemented = true)
 
   tests('success') do
 
-    if !Fog.mocking? || mocks_implemented
-      @instance = collection.new(params)
-    end
+    @instance = collection.new(params)
 
     tests("#save").succeeds do
       pending if Fog.mocking? && !mocks_implemented

data/tests/helpers/responds_to_helper.rb

@@ -3,11 +3,11 @@ module Shindo
 
     def responds_to(method_names)
       for method_name in [*method_names]
-        tests("#respond_to?(:#{method_name})").succeeds do
+        tests("#respond_to?(:#{method_name})").returns(true) do
           @instance.respond_to?(method_name)
         end
       end
     end
 
   end
-end
+end

data/tests/storage/helper.rb

@@ -7,7 +7,7 @@ def storage_providers
       :mocked => true
     },
     Local     => {
-      :mocked => true
+      :mocked => false
     },
     Rackspace => {
       :mocked => false