fog 1.1.0 → 1.2.0

data/tests/aws/requests/storage/bucket_tests.rb

@@ -117,7 +117,6 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
     end
 
     tests("#put_bucket_website('#{@aws_bucket_name}', 'index.html')").succeeds do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_bucket_website(@aws_bucket_name, 'index.html')
     end
 
@@ -135,8 +134,6 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       ]
     }
     tests("#put_bucket_acl('#{@aws_bucket_name}', hash with id)").returns(acl) do
-      pending if Fog.mocking?
-
       Fog::Storage[:aws].put_bucket_acl(@aws_bucket_name, acl)
       Fog::Storage[:aws].get_bucket_acl(@aws_bucket_name).body
     end
@@ -173,7 +170,6 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       ]
     }
     tests("#put_bucket_acl('#{@aws_bucket_name}', hash with uri)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_bucket_acl(@aws_bucket_name, acl)
       Fog::Storage[:aws].get_bucket_acl(@aws_bucket_name).body
     end
@@ -183,6 +179,68 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       Fog::Storage[:aws].delete_bucket_website(@aws_bucket_name)
     end
 
+    tests('bucket lifecycle') do
+      pending if Fog.mocking?
+
+      lifecycle = {'Rules' => [{'ID' => 'test rule', 'Prefix' => '/prefix', 'Enabled' => true, 'Days' => 42}]}
+      tests('non-existant bucket') do
+        tests('#put_bucket_lifecycle').returns([404, 'NoSuchBucket']) do
+          begin
+            Fog::Storage[:aws].put_bucket_lifecycle('fognonbucket', lifecycle)
+          rescue Excon::Errors::NotFound => e
+            [e.response.status, e.response.body.match(%r{<Code>(.*)</Code>})[1]]
+          end
+        end
+        tests('#get_bucket_lifecycle').returns([404, 'NoSuchBucket']) do
+          begin
+            Fog::Storage[:aws].get_bucket_lifecycle('fognonbucket')
+          rescue Excon::Errors::NotFound => e
+            [e.response.status, e.response.body.match(%r{<Code>(.*)</Code>})[1]]
+          end
+        end
+        tests('#delete_bucket_lifecycle').returns([404, 'NoSuchBucket']) do
+          begin
+            Fog::Storage[:aws].delete_bucket_lifecycle('fognonbucket')
+          rescue Excon::Errors::NotFound => e
+            [e.response.status, e.response.body.match(%r{<Code>(.*)</Code>})[1]]
+          end
+        end
+      end
+      tests('no lifecycle') do
+        tests('#get_bucket_lifecycle').returns([404, 'NoSuchLifecycleConfiguration']) do
+          begin
+            Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name)
+          rescue Excon::Errors::NotFound => e
+            [e.response.status, e.response.body.match(%r{<Code>(.*)</Code>})[1]]
+          end
+        end
+        tests('#delete_bucket_lifecycle').succeeds do
+          Fog::Storage[:aws].delete_bucket_lifecycle(@aws_bucket_name)
+        end
+      end
+      tests('create').succeeds do
+        Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
+      end
+      tests('read').returns(lifecycle) do
+        Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
+      end
+      lifecycle = { 'Rules' => 5.upto(6).map { |i| {'ID' => "rule\##{i}", 'Prefix' => i.to_s, 'Enabled' => true, 'Days' => i} } }
+      tests('update').returns(lifecycle) do
+        Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
+        Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
+      end
+      tests('delete').succeeds do
+          Fog::Storage[:aws].delete_bucket_lifecycle(@aws_bucket_name)
+      end
+      tests('read').returns([404, 'NoSuchLifecycleConfiguration']) do
+        begin
+          Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name)
+        rescue Excon::Errors::NotFound => e
+          [e.response.status, e.response.body.match(%r{<Code>(.*)</Code>})[1]]
+        end
+      end
+    end
+
     tests("#delete_bucket('#{@aws_bucket_name}')").succeeds do
       Fog::Storage[:aws].delete_bucket(@aws_bucket_name)
     end
@@ -225,6 +283,10 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', [:aws]) do
       Fog::Storage[:aws].put_bucket_acl('fognonbucket', 'invalid')
     end
 
+    tests("#put_bucket_website('fognonbucket', 'index.html')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].put_bucket_website('fognonbucket', 'index.html')
+    end
+
   end
 
   # don't keep the bucket around

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

@@ -37,13 +37,12 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
     acl = {
       'Owner' => @aws_owner,
       'AccessControlList' => [
-        { 
+        {
           'Grantee' => @aws_owner,
-          'Permission' => "FULL_CONTROL" 
+          'Permission' => "FULL_CONTROL"
         }
       ]}
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', hash with id)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', acl)
       Fog::Storage[:aws].get_object_acl(@directory.identity, 'fog_object').body
     end
@@ -77,7 +76,6 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
         }
       ]}
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', hash with uri)").returns(acl) do
-      pending if Fog.mocking?
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', acl)
       Fog::Storage[:aws].get_object_acl(@directory.identity, 'fog_object').body
     end

data/tests/aws/requests/storage/versioning_tests.rb

@@ -0,0 +1,188 @@
+def clear_bucket
+  Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name).body['Versions'].each do |version|
+    object = version[version.keys.first]
+    Fog::Storage[:aws].delete_object(@aws_bucket_name, object['Key'], 'versionId' => object['VersionId'])
+  end
+end
+
+def create_versioned_bucket
+  @aws_bucket_name = 'fogbuckettests-' + Fog::Mock.random_hex(16)
+  Fog::Storage[:aws].put_bucket(@aws_bucket_name)
+  Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'Enabled')
+end
+
+def delete_bucket
+  Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name).body['Versions'].each do |version|
+    object = version[version.keys.first]
+    Fog::Storage[:aws].delete_object(@aws_bucket_name, object['Key'], 'versionId' => object['VersionId'])
+  end
+
+  Fog::Storage[:aws].delete_bucket(@aws_bucket_name)
+end
+
+Shindo.tests('Fog::Storage[:aws] | versioning', [:aws]) do
+  tests('success') do
+    tests("#put_bucket_versioning") do
+      @aws_bucket_name = 'fogbuckettests-' + Fog::Mock.random_hex(16)
+      Fog::Storage[:aws].put_bucket(@aws_bucket_name)
+
+      tests("#put_bucket_versioning('#{@aws_bucket_name}', 'Enabled')").succeeds do
+        Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'Enabled')
+      end
+
+      tests("#put_bucket_versioning('#{@aws_bucket_name}', 'Suspended')").succeeds do
+        Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'Suspended')
+      end
+
+      delete_bucket
+    end
+
+    tests("#get_bucket_versioning('#{@aws_bucket_name}')") do
+      @aws_bucket_name = 'fogbuckettests-' + Fog::Mock.random_hex(16)
+      Fog::Storage[:aws].put_bucket(@aws_bucket_name)
+
+      tests("#get_bucket_versioning('#{@aws_bucket_name}') without versioning").returns({}) do
+        Fog::Storage[:aws].get_bucket_versioning(@aws_bucket_name).body['VersioningConfiguration']
+      end
+
+      tests("#get_bucket_versioning('#{@aws_bucket_name}') with versioning enabled").returns('Enabled') do
+        Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'Enabled')
+        Fog::Storage[:aws].get_bucket_versioning(@aws_bucket_name).body['VersioningConfiguration']['Status']
+      end
+
+      tests("#get_bucket_versioning('#{@aws_bucket_name}') with versioning suspended").returns('Suspended') do
+        Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'Suspended')
+        Fog::Storage[:aws].get_bucket_versioning(@aws_bucket_name).body['VersioningConfiguration']['Status']
+      end
+
+      delete_bucket
+    end
+
+    tests("#get_bucket_object_versions('#{@aws_bucket_name}')") do
+
+      create_versioned_bucket
+
+      before do
+        @versions = Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name)
+      end
+
+      v1 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'a',    :key => 'file')
+      v2 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'ab',   :key => v1.key)
+      v3 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'abc',  :key => v1.key)
+      v4 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'abcd', :key => v1.key)
+
+      tests("versions").returns([v4.version, v3.version, v2.version, v1.version]) do
+        @versions.body['Versions'].collect {|v| v['Version']['VersionId']}
+      end
+
+      tests("version sizes").returns([4, 3, 2, 1]) do
+        @versions.body['Versions'].collect {|v| v['Version']['Size']}
+      end
+
+      tests("latest version").returns(v4.version) do
+        latest = @versions.body['Versions'].find {|v| v['Version']['IsLatest']}
+        latest['Version']['VersionId']
+      end
+    end
+
+    tests("get_object('#{@aws_bucket_name}', 'file')") do
+      clear_bucket
+
+      v1 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'a',  :key => 'file')
+      v2 = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'ab', :key => v1.key)
+
+      tests("get_object('#{@aws_bucket_name}', '#{v2.key}') returns the latest version").returns(v2.version) do
+        res = Fog::Storage[:aws].get_object(@aws_bucket_name, v2.key)
+        res.headers['x-amz-version-id']
+      end
+
+      tests("get_object('#{@aws_bucket_name}', '#{v1.key}', 'versionId' => '#{v1.version}') returns the specified version").returns(v1.version) do
+        res = Fog::Storage[:aws].get_object(@aws_bucket_name, v1.key, 'versionId' => v1.version)
+        res.headers['x-amz-version-id']
+      end
+
+      v2.destroy
+
+      tests("get_object('#{@aws_bucket_name}', '#{v2.key}') raises exception if delete marker is latest version").raises(Excon::Errors::NotFound) do
+        Fog::Storage[:aws].get_object(@aws_bucket_name, v2.key)
+      end
+    end
+
+    tests("delete_object('#{@aws_bucket_name}', 'file')") do
+      clear_bucket
+
+      file = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'a',  :key => 'file')
+
+      tests("deleting an object just stores a delete marker").returns(true) do
+        file.destroy
+        versions = Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name)
+        versions.body['Versions'].first.has_key?('DeleteMarker')
+      end
+
+      tests("there are two versions: the original and the delete marker").returns(2) do
+        versions = Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name)
+        versions.body['Versions'].size
+      end
+
+      tests("deleting the delete marker makes the object available again").returns(file.version) do
+        versions = Fog::Storage[:aws].get_bucket_object_versions(@aws_bucket_name)
+        delete_marker = versions.body['Versions'].find { |v| v.has_key?('DeleteMarker') }
+        Fog::Storage[:aws].delete_object(@aws_bucket_name, file.key, 'versionId' => delete_marker['DeleteMarker']['VersionId'])
+
+        res = Fog::Storage[:aws].get_object(@aws_bucket_name, file.key)
+        res.headers['x-amz-version-id']
+      end
+    end
+
+    tests("get_bucket('#{@aws_bucket_name}'") do
+      clear_bucket
+
+      file = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'a',  :key => 'file')
+
+      tests("includes a non-DeleteMarker object").returns(1) do
+        Fog::Storage[:aws].get_bucket(@aws_bucket_name).body['Contents'].size
+      end
+
+      file.destroy
+
+      tests("does not include a DeleteMarker object").returns(0) do
+        Fog::Storage[:aws].get_bucket(@aws_bucket_name).body['Contents'].size
+      end
+    end
+
+    delete_bucket
+  end
+
+  tests('failure') do
+    create_versioned_bucket
+
+    tests("#put_bucket_versioning('#{@aws_bucket_name}', 'bad_value')").raises(Excon::Errors::BadRequest) do
+      Fog::Storage[:aws].put_bucket_versioning(@aws_bucket_name, 'bad_value')
+    end
+
+    tests("#put_bucket_versioning('fognonbucket', 'Enabled')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].put_bucket_versioning('fognonbucket', 'Enabled')
+    end
+
+    tests("#get_bucket_versioning('fognonbucket')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].get_bucket_versioning('fognonbucket')
+    end
+
+    tests("#get_bucket_object_versions('fognonbucket')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].get_bucket_object_versions('fognonbucket')
+    end
+
+    file = Fog::Storage[:aws].directories.get(@aws_bucket_name).files.create(:body => 'y', :key => 'x')
+
+    tests("#get_object('#{@aws_bucket_name}', '#{file.key}', 'versionId' => 'bad_version'").raises(Excon::Errors::BadRequest) do
+      Fog::Storage[:aws].get_object(@aws_bucket_name, file.key, 'versionId' => '-1')
+    end
+
+    tests("#delete_object('#{@aws_bucket_name}', '#{file.key}', 'versionId' => 'bad_version'").raises(Excon::Errors::BadRequest) do
+      Fog::Storage[:aws].delete_object(@aws_bucket_name, file.key, 'versionId' => '-1')
+    end
+  end
+
+  # don't keep the bucket around
+  delete_bucket
+end

data/tests/aws/requests/sts/get_federation_token_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('AWS::STS | session tokens', ['aws']) do
+
+	@policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+	@federation_format = {
+		'SessionToken' => String,
+		'SecretAccessKey' => String,
+		'Expiration' => String,
+		'AccessKeyId' => String,
+		'Arn' => String,
+		'FederatedUserId' => String,
+		'PackedPolicySize' => String,
+		'RequestId'	=> String
+	}
+
+	tests("#get_federation_token('test@fog.io', #{@policy.inspect})").formats(@federation_format) do
+		pending if Fog.mocking?
+		Fog::AWS[:sts].get_federation_token("test@fog.io", @policy).body
+	end
+	
+end

data/tests/aws/requests/sts/session_token_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('AWS::STS | session tokens', ['aws']) do
+
+	@session_format = {
+		'SessionToken' => String,
+		'SecretAccessKey' => String,
+		'Expiration' => String,
+		'AccessKeyId' => String,
+		'RequestId'	=> String
+	}
+
+	tests("#get_session_token").formats(@session_format) do
+		pending if Fog.mocking?
+		Fog::AWS[:sts].get_session_token.body
+	end
+	
+end

data/tests/bluebox/requests/compute/block_tests.rb

@@ -8,23 +8,24 @@ Shindo.tests('Fog::Compute[:bluebox] | block requests', ['bluebox']) do
     'ips'             => [{'address' => String}],
     'lb_applications' => [],
     'memory'          => Integer,
-    'product'         => Bluebox::Compute::Formats::PRODUCT,
+    'product'         => {'cost' => String, 'description' => String, 'id' => String},
     'status'          => String,
     'storage'         => Integer,
-    'template'        => String
+    'location_id'     => String
   }
 
   tests('success') do
 
-    @product_id   = '94fd37a7-2606-47f7-84d5-9000deda52ae' # 1 GB
-    @template_id  = compute_providers[:bluebox][:server_attributes][:image_id]
-    @password     = 'chunkybacon'
+    @flavor_id    = compute_providers[:bluebox][:server_attributes][:flavor_id]
+    @image_id     = compute_providers[:bluebox][:server_attributes][:image_id]
+    @location_id  = compute_providers[:bluebox][:server_attributes][:location_id]
+    @password     = compute_providers[:bluebox][:server_attributes][:password]
 
     @block_id = nil
 
-    tests("create_block('#{@product_id}', '#{@template_id}', {'password' => '#{@password}'})").formats(@block_format.merge('add_to_lb_application_results' => {'text' => String})) do
+    tests("create_block('#{@flavor_id}', '#{@image_id}', '#{@location_id}', {'password' => '#{@password}'})").formats(@block_format.merge('add_to_lb_application_results' => {'text' => String})) do
       pending if Fog.mocking?
-      data = Fog::Compute[:bluebox].create_block(@product_id, @template_id, {'password' => @password}).body
+      data = Fog::Compute[:bluebox].create_block(@flavor_id, @image_id, @location_id, {'password' => @password}).body
       @block_id = data['id']
       data
     end
@@ -43,7 +44,7 @@ Shindo.tests('Fog::Compute[:bluebox] | block requests', ['bluebox']) do
       Fog::Compute[:bluebox].get_blocks.body
     end
 
-    tests("reboot_block('#{@block_id}')").formats({'status' => String, 'text' => String}) do
+    tests("reboot_block('#{@block_id}')").formats([{'status' => String}, {'text' => String}]) do
       pending if Fog.mocking?
       Fog::Compute[:bluebox].reboot_block(@block_id).body
     end

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

@@ -8,6 +8,11 @@ class Bluebox
         'cost'        => String,
         'description' => String,
         'id'          => String
+      },
+      
+      LOCATION = {
+        'id'          => String,
+        'description' => String
       }
 
     end

data/tests/bluebox/requests/compute/location_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests('Fog::Compute[:bluebox] | location requests', ['bluebox']) do
+  
+  @location_format = {
+    'id'          => String,
+    'description' => String
+  }
+  
+  tests('success') do
+
+    @location_id  = compute_providers[:bluebox][:server_attributes][:location_id]
+
+    tests("get_location('#{@location_id}')").formats(@location_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:bluebox].get_location(@location_id).body
+    end
+
+    tests("get_locations").formats([@location_format]) do
+      pending if Fog.mocking?
+      Fog::Compute[:bluebox].get_locations.body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("get_location('00000000-0000-0000-0000-000000000000')").raises(Fog::Compute::Bluebox::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:bluebox].get_location('00000000-0000-0000-0000-000000000000')
+    end
+
+  end
+end

data/tests/bluebox/requests/compute/product_tests.rb

@@ -1,15 +1,21 @@
 Shindo.tests('Fog::Compute[:bluebox] | product requests', ['bluebox']) do
 
+  @product_format = {
+    'id' => String,
+    'description' => String,
+    'cost' => String
+  }
+
   tests('success') do
 
-    @product_id   = '94fd37a7-2606-47f7-84d5-9000deda52ae' # 1 GB
+    @flavor_id = compute_providers[:bluebox][:server_attributes][:flavor_id]
 
-    tests("get_product('#{@product_id}')").formats(Bluebox::Compute::Formats::PRODUCT) do
+    tests("get_product('#{@flavor_id}')").formats(@product_format) do
       pending if Fog.mocking?
-      Fog::Compute[:bluebox].get_product(@product_id).body
+      Fog::Compute[:bluebox].get_product(@flavor_id).body
     end
 
-    tests("get_products").formats([Bluebox::Compute::Formats::PRODUCT]) do
+    tests("get_products").formats([@product_format]) do
       pending if Fog.mocking?
       Fog::Compute[:bluebox].get_products.body
     end

data/tests/bluebox/requests/compute/template_tests.rb

@@ -4,12 +4,14 @@ Shindo.tests('Fog::Compute[:bluebox] | template requests', ['bluebox']) do
     'created'     => String,
     'description' => String,
     'id'          => String,
-    'public'      => Fog::Boolean
+    'public'      => Fog::Boolean,
+    'locations'   => [ String ],
+    'status'      => String
   }
 
   tests('success') do
 
-    @template_id  = '03807e08-a13d-44e4-b011-ebec7ef2c928' # Ubuntu LTS 10.04 64bit
+    @template_id = compute_providers[:bluebox][:server_attributes][:image_id]
 
     tests("get_template('#{@template_id}')").formats(@template_format) do
       pending if Fog.mocking?

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

@@ -2,20 +2,25 @@ Shindo.tests('Fog::Compute[:brightbox] | account requests', ['brightbox']) do
 
   tests('success') do
 
-    tests("#get_account").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#get_account") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_account
+      result = Fog::Compute[:brightbox].get_account
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
+      test("ftp password is blanked") { result["library_ftp_password"].nil?  }
     end
 
     update_options = {:name => "Fog@#{Time.now.iso8601}"}
-    tests("#update_account(#{update_options.inspect})").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#update_account(#{update_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_account(update_options)
+      result = Fog::Compute[:brightbox].update_account(update_options)
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
     end
 
-    tests("#reset_ftp_password_account").formats(Brightbox::Compute::Formats::Full::ACCOUNT) do
+    tests("#reset_ftp_password_account") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].reset_ftp_password_account
+      result = Fog::Compute[:brightbox].reset_ftp_password_account
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
+      test("new ftp password is visible") { ! result["library_ftp_password"].nil?  }
     end
 
   end

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

@@ -7,32 +7,43 @@ Shindo.tests('Fog::Compute[:brightbox] | api client requests', ['brightbox']) do
       :description => "Description from Fog test"
     }
 
-    tests("#create_api_client(#{create_options.inspect})").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#create_api_client(#{create_options.inspect})") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].create_api_client(create_options)
-      @api_client_id = data["id"]
-      data
+      result = Fog::Compute[:brightbox].create_api_client(create_options)
+      @api_client_id = result["id"]
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT, false) { result }
     end
 
-    tests("#list_api_clients").formats(Brightbox::Compute::Formats::Collection::API_CLIENTS) do
+    tests("#list_api_clients") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].list_api_clients
+      result = Fog::Compute[:brightbox].list_api_clients
+      formats(Brightbox::Compute::Formats::Collection::API_CLIENTS, false) { result }
     end
 
-    tests("#get_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#get_api_client('#{@api_client_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_api_client(@api_client_id)
+      result = Fog::Compute[:brightbox].get_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT, false) { result }
     end
 
     update_options = {:name => "Fog@#{Time.now.iso8601}"}
-    tests("#update_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#update_api_client('#{@api_client_id}', #{update_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].update_api_client(@api_client_id, update_options)
+      result = Fog::Compute[:brightbox].update_api_client(@api_client_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT, false) { result }
     end
 
-    tests("#destroy_api_client('#{@api_client_id}')").formats(Brightbox::Compute::Formats::Full::API_CLIENT) do
+    tests("#reset_secret_api_client('#{@api_client_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].destroy_api_client(@api_client_id)
+      result = Fog::Compute[:brightbox].reset_secret_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT, false) { result }
+      test("new secret is visible") { ! result["secret"].nil?  }
+    end
+
+    tests("#destroy_api_client('#{@api_client_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].destroy_api_client(@api_client_id)
+      formats(Brightbox::Compute::Formats::Full::API_CLIENT, false) { result }
     end
 
   end

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

@@ -3,48 +3,63 @@ Shindo.tests('Fog::Compute[:brightbox] | cloud ip requests', ['brightbox']) do
   tests('success') do
 
     unless Fog.mocking?
-      @server = Fog::Compute[:brightbox].servers.create(compute_providers[:brightbox][:server_attributes])
+      @server = Brightbox::Compute::TestSupport.get_test_server
     end
 
-    tests("#create_cloud_ip").formats(Brightbox::Compute::Formats::Full::CLOUD_IP) do
+    tests("#create_cloud_ip") do
       pending if Fog.mocking?
-      data = Fog::Compute[:brightbox].create_cloud_ip
-      @cloud_ip_id = data["id"]
-      data
+      result = Fog::Compute[:brightbox].create_cloud_ip
+      @cloud_ip_id = result["id"]
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
     end
 
-    tests("#list_cloud_ips").formats(Brightbox::Compute::Formats::Collection::CLOUD_IPS) do
+    tests("#list_cloud_ips") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].list_cloud_ips
+      result = Fog::Compute[:brightbox].list_cloud_ips
+      formats(Brightbox::Compute::Formats::Collection::CLOUD_IPS, false) { result }
     end
 
-    tests("#get_cloud_ip('#{@cloud_ip_id}')").formats(Brightbox::Compute::Formats::Full::CLOUD_IP) do
+    tests("#get_cloud_ip('#{@cloud_ip_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].get_cloud_ip(@cloud_ip_id)
+      result = Fog::Compute[:brightbox].get_cloud_ip(@cloud_ip_id)
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
     end
 
     unless Fog.mocking?
-      @server.wait_for { ready? }
-      map_options = {:interface => @server.interfaces.first["id"]}
+      map_options = {:destination => @server.interfaces.first["id"]}
     end
 
-    tests("#map_cloud_ip('#{@cloud_ip_id}', #{map_options.inspect})").formats(Brightbox::Compute::Formats::Full::CLOUD_IP) do
+    tests("#map_cloud_ip('#{@cloud_ip_id}', #{map_options.inspect})") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].map_cloud_ip(@cloud_ip_id, map_options)
+      result = Fog::Compute[:brightbox].map_cloud_ip(@cloud_ip_id, map_options)
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
     end
 
     unless Fog.mocking?
       Fog::Compute[:brightbox].cloud_ips.get(@cloud_ip_id).wait_for { mapped? }
     end
 
-    tests("#unmap_cloud_ip('#{@cloud_ip_id}')").formats(Brightbox::Compute::Formats::Full::CLOUD_IP) do
+    tests("#unmap_cloud_ip('#{@cloud_ip_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].unmap_cloud_ip(@cloud_ip_id)
+      result = Fog::Compute[:brightbox].unmap_cloud_ip(@cloud_ip_id)
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
     end
 
-    tests("#destroy_cloud_ip('#{@cloud_ip_id}')").formats(Brightbox::Compute::Formats::Full::CLOUD_IP) do
+    unless Fog.mocking?
+      update_options = {:reverse_dns => "public.#{@server.id}.gb1.brightbox.com"}
+    end
+
+    tests("#update_cloud_ip('#{@cloud_ip_id}', #{update_options.inspect})") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].update_cloud_ip(@cloud_ip_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
+      result = Fog::Compute[:brightbox].update_cloud_ip(@cloud_ip_id, {:reverse_dns => ""})
+    end
+
+    tests("#destroy_cloud_ip('#{@cloud_ip_id}')") do
       pending if Fog.mocking?
-      Fog::Compute[:brightbox].destroy_cloud_ip(@cloud_ip_id)
+      result = Fog::Compute[:brightbox].destroy_cloud_ip(@cloud_ip_id)
+      formats(Brightbox::Compute::Formats::Full::CLOUD_IP, false) { result }
     end
 
     unless Fog.mocking?