hackerdude-aws 2.3.25

data/test/http_connection.rb

@@ -0,0 +1,87 @@
+=begin
+Copyright (c) 2007 RightScale, Inc. 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+# Stub extension/redefinition of RightHttpConnection for testing purposes.
+require 'net/http'
+require 'rubygems'
+require 'right_http_connection'
+
+module Net
+  class HTTPResponse
+  alias_method :real_body, :body
+    def setmsg(msg)
+      @mymsg = msg
+    end
+
+    def body
+      # defined?() helps us to get rid of a bunch of 'warnings'
+      (defined?(@mymsg) && @mymsg) ? @mymsg : real_body
+    end
+  end
+end
+
+module Rightscale
+
+  class HttpConnection
+    @@response_stack = []
+
+    alias_method :real_request, :request
+
+    def request(request_params, &block)
+      if(@@response_stack.length == 0)
+        return real_request(request_params, &block)
+      end
+
+      if(block)
+        # Do something special
+      else
+        next_response = HttpConnection::pop() 
+        classname = Net::HTTPResponse::CODE_TO_OBJ["#{next_response[:code]}"]
+        response = classname.new("1.1", next_response[:code], next_response[:msg])
+        if(next_response[:msg])
+          response.setmsg(next_response[:msg])
+        end
+        response
+      end
+    end
+
+    def self.reset
+      @@response_stack = []
+    end
+
+    def self.push(code, msg=nil)
+      response = {:code => code, :msg => msg}
+      @@response_stack << response
+    end
+
+    def self.pop
+      @@response_stack.pop
+    end
+
+    def self.length
+      @@response_stack.length
+    end
+
+  end
+
+end

data/test/rds/test_rds.rb

@@ -0,0 +1,181 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/aws'
+require 'rds/rds'
+require 'pp'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestRds < Test::Unit::TestCase
+
+    # Some of RightEc2 instance methods concerning instance launching and image registration
+    # are not tested here due to their potentially risk.
+
+    def setup
+        TestCredentials.get_credentials
+
+        @rds = Aws::Rds.new(TestCredentials.aws_access_key_id,
+                            TestCredentials.aws_secret_access_key)
+
+        @identifier = 'test-db-instance1b'
+        # deleting this one....
+        #@identifier2 = 'my-db-instance2'
+    end
+
+
+    def test_00_describe_db_instances_empty
+        instances = @rds.describe_db_instances
+#        puts "instances_result=" + instances_result.inspect
+#        instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
+        puts "instances count = " + instances.count.to_s
+        puts 'instances=' + instances.inspect
+        assert instances.size == 0
+    end
+
+
+    def test_01_create_db_instance
+        begin
+            db_instance3 = @rds.create_db_instance('bad_test_key', "db.m1.small", 5, "master", "masterpass")
+        rescue => ex
+            #puts "msg=" + ex.message
+            #puts "response=" + ex.response
+            assert ex.message[0, "InvalidParameterValue".size] == "InvalidParameterValue"
+        end
+
+        db_instance = @rds.create_db_instance(@identifier, "db.m1.small", 5, "master", "masterpass")
+        assert db_instance[:db_instance_status] == "creating"
+
+        start = Time.now
+        tries=0
+        catch (:done)  do
+            while tries < 100
+                instances = @rds.describe_db_instances
+
+                #puts "INSTANCES -----> " + instances.inspect
+
+                instances.each do |i|
+                    db_status = i[:db_instance_status]
+                    puts 'i=' + db_status.to_s
+                    next unless i[:db_instance_identifier] == @identifier
+                    throw :done if db_status == "available"
+                    puts "Database not ready yet.... attempt #{tries.to_s} of 100, db state --> #{i[:db_instance_status].to_s}"
+                    tries += 1
+                    sleep 5
+                end
+            end
+        end
+        puts "Duration to start db instance: #{Time.now-start}"
+    end
+
+
+    def test_02_describe_db_instances
+        instances = @rds.describe_db_instances
+#        puts "instances_result=" + instances_result.inspect
+#        instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
+        puts "instances count = " + instances.count.to_s
+        puts 'instances=' + instances.inspect
+        assert instances.size > 0
+        i_describe = nil
+        instances.each do |rdi|
+            puts 'rdi=' + rdi.inspect
+            i_describe = rdi if rdi[:db_instance_identifier] == @identifier
+        end
+        assert i_describe
+
+        puts 'response_metadata=' + instances.response_metadata.inspect
+        assert instances.response_metadata
+        assert instances.response_metadata[:request_id]
+    end
+
+
+    def test_03_describe_security_groups
+        security_groups = @rds.describe_db_security_groups()
+        puts "security_groups=" + security_groups.inspect
+        default_present = false
+        assert security_groups.is_a?(Array)
+        security_groups.each do |security_group|
+            security_group.inspect
+            if security_group[:db_security_group_name] == "default"
+                default_present=true
+            end
+            assert security_group[:ec2_security_groups].is_a? Array
+        end
+        assert default_present
+    end
+
+
+    def test_04_authorize_security_groups_ingress
+        # Create
+#        security_groups = @rds.describe_db_security_groups
+#        @security_info = security_groups[0]
+        @rds.authorize_db_security_group_ingress_range("default", "122.122.122.122/12")
+
+        # Check
+        security_groups = @rds.describe_db_security_groups
+        @security_info = security_groups[0]
+
+        ip_found = @security_info.inspect.include? "122.122.122.122/12"
+        assert ip_found
+    end
+
+
+    def test_05_delete_db_instance
+        @rds.delete_db_instance(@identifier) # todo: can't delete unless it's in "available" state
+        #@rds.delete_db_instance(@identifier2)
+        sleep 3
+
+        instances = @rds.describe_db_instances(:db_instance_identifier=>@identifier)
+        #puts "instances_result=" + instances_result.inspect
+
+        instances.each do |i|
+            next unless i[:db_instance_identifier] == @identifier
+            db_status = i[:db_instance_status]
+            puts "Trying to delete and getting i[DBInstanceStatus] -----------> " + db_status
+            @rds.delete_db_instance(i[:db_instance_identifier]) if db_status == "available"
+            assert db_status == "deleting"
+        end
+        sleep 2
+
+    end
+
+
+    def test_06_create_security_groups
+        group_present=false
+
+        @rds.create_db_security_group("new_sample_group", "new_sample_group_description")
+
+        security_groups = @rds.describe_db_security_groups
+
+        security_groups.each do |security_group|
+            if (security_group[:db_security_group_name]=="new_sample_group")&&(security_group[:db_security_group_description]=="new_sample_group_description")
+                group_present = true
+            end
+        end
+
+        assert group_present
+    end
+
+
+    def test_07_revoking_security_groups_ingress
+#        sleep 15
+        @rds.revoke_db_security_group_ingress("default", "122.122.122.122/12")
+        sleep 2
+        security_groups = @rds.describe_db_security_groups
+        revoking = security_groups[0].inspect.include? "revoking"
+        assert revoking
+    end
+
+
+    def test_08_delete_security_group
+        group_present=false
+        @rds.delete_db_security_group("new_sample_group")
+        sleep 2
+        security_groups = @rds.describe_db_security_groups
+        security_groups.each do |security_group|
+            if (security_group[:db_security_group_name]=="new_sample_group")
+                group_present=true
+            end
+        end
+        assert !group_present
+    end
+
+
+end

data/test/s3/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/aws'
+

data/test/s3/test_s3.rb

@@ -0,0 +1,425 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestS3 < Test::Unit::TestCase
+
+    RIGHT_OBJECT_TEXT = 'Right test message'
+
+    def setup
+        TestCredentials.get_credentials
+        @s3 = Aws::S3Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+        @bucket = TestCredentials.config['amazon']['my_prefix'] + '_awesome_test_bucket_000A1'
+        @bucket2 = TestCredentials.config['amazon']['my_prefix'] + '_awesome_test_bucket_000A2'
+        @key1 = 'test/woohoo1/'
+        @key2 = 'test1/key/woohoo2'
+        @key3 = 'test2/A%B@C_D&E?F+G=H"I'
+        @key1_copy = 'test/woohoo1_2'
+        @key1_new_name = 'test/woohoo1_3'
+        @key2_new_name = 'test1/key/woohoo2_new'
+        @s = Aws::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+    end
+
+    def teardown
+        
+    end
+
+    #---------------------------
+    # Aws::S3Interface
+    #---------------------------
+
+    def test_01_create_bucket
+        assert @s3.create_bucket(@bucket), 'Create_bucket fail'
+    end
+
+    def test_02_list_all_my_buckets
+        assert @s3.list_all_my_buckets.map{|bucket| bucket[:name]}.include?(@bucket), "#{@bucket} must exist in bucket list"
+    end
+
+    def test_03_list_empty_bucket
+        assert_equal 0, @s3.list_bucket(@bucket).size, "#{@bucket} isn't empty, arrgh!"
+    end
+
+    def test_04_put
+        assert @s3.put(@bucket, @key1, RIGHT_OBJECT_TEXT, 'x-amz-meta-family'=>'Woohoo1!'), 'Put bucket fail'
+        assert @s3.put(@bucket, @key2, RIGHT_OBJECT_TEXT, 'x-amz-meta-family'=>'Woohoo2!'), 'Put bucket fail'
+        assert @s3.put(@bucket, @key3, RIGHT_OBJECT_TEXT, 'x-amz-meta-family'=>'Woohoo3!'), 'Put bucket fail'
+    end
+
+    def test_05_get_and_get_object
+        assert_raise(Aws::AwsError) { @s3.get(@bucket, 'undefined/key') }
+        data1 = @s3.get(@bucket, @key1)
+        assert_equal RIGHT_OBJECT_TEXT, data1[:object], "Object text must be equal to '#{RIGHT_OBJECT_TEXT}'"
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key1), "Get_object text must return '#{RIGHT_OBJECT_TEXT}'"
+        assert_equal 'Woohoo1!', data1[:headers]['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key3), "Get_object text must return '#{RIGHT_OBJECT_TEXT}'"
+    end
+
+    def test_06_head
+        assert_equal 'Woohoo1!', @s3.head(@bucket, @key1)['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+    end
+
+
+    def test_07_streaming_get
+        resp = String.new
+        assert_raise(Aws::AwsError) do
+            @s3.get(@bucket, 'undefined/key') do |chunk|
+                resp += chunk
+            end
+        end
+
+        resp = String.new
+        data1 = @s3.get(@bucket, @key1) do |chunk|
+            resp += chunk
+        end
+        assert_equal RIGHT_OBJECT_TEXT, resp, "Object text must be equal to '#{RIGHT_OBJECT_TEXT}'"
+        assert_equal @s3.get_object(@bucket, @key1), resp, "Streaming iface must return same as non-streaming"
+        assert_equal 'Woohoo1!', data1[:headers]['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+    end
+
+    def test_08_keys
+        keys = @s3.list_bucket(@bucket).map{|b| b[:key]}
+        assert_equal keys.size, 3, "There should be 3 keys"
+        assert(keys.include?(@key1))
+        assert(keys.include?(@key2))
+        assert(keys.include?(@key3))
+    end
+
+    def test_09_copy_key
+        #--- test COPY
+        # copy a key
+        assert @s3.copy(@bucket, @key1, @bucket, @key1_copy)
+        # check it was copied well
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key1_copy), "copied object must have the same data"
+        # check meta-headers were copied
+        headers = @s3.head(@bucket, @key1_copy)
+        assert_equal 'Woohoo1!', headers['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+        #--- test REPLACE
+        assert @s3.copy(@bucket, @key1, @bucket, @key1_copy, :replace, 'x-amz-meta-family' => 'oooops!')
+        # check it was copied well
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key1_copy), "copied object must have the same data"
+        # check meta-headers were overwrittenn
+        headers = @s3.head(@bucket, @key1_copy)
+        assert_equal 'oooops!', headers['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'oooops!'"
+    end
+
+    def test_10_move_key
+        # move a key
+        assert @s3.move(@bucket, @key1, @bucket, @key1_new_name)
+        # check it's data was moved correctly
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key1_new_name), "moved object must have the same data"
+        # check meta-headers were moved
+        headers = @s3.head(@bucket, @key1_new_name)
+        assert_equal 'Woohoo1!', headers['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+        # check the original key is not exists any more
+        keys = @s3.list_bucket(@bucket).map{|b| b[:key]}
+        assert(!keys.include?(@key1))
+    end
+
+    def test_11_rename_key
+        # rename a key
+        assert @s3.rename(@bucket, @key2, @key2_new_name)
+        # check the new key data
+        assert_equal RIGHT_OBJECT_TEXT, @s3.get_object(@bucket, @key2_new_name), "moved object must have the same data"
+        # check meta-headers
+        headers = @s3.head(@bucket, @key2_new_name)
+        assert_equal 'Woohoo2!', headers['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo2!'"
+        # check the original key is not exists any more
+        keys = @s3.list_bucket(@bucket).map{|b| b[:key]}
+        assert(!keys.include?(@key2))
+    end
+
+    def test_12_retrieve_object
+        assert_raise(Aws::AwsError) { @s3.retrieve_object(:bucket => @bucket, :key => 'undefined/key') }
+        data1 = @s3.retrieve_object(:bucket => @bucket, :key => @key1_new_name)
+        assert_equal RIGHT_OBJECT_TEXT, data1[:object], "Object text must be equal to '#{RIGHT_OBJECT_TEXT}'"
+        assert_equal 'Woohoo1!', data1[:headers]['x-amz-meta-family'], "x-amz-meta-family header must be equal to 'Woohoo1!'"
+    end
+
+    def test_13_delete_folder
+        assert_equal 1, @s3.delete_folder(@bucket, 'test').size, "Only one key(#{@key1}) must be deleted!"
+    end
+
+    def test_14_delete_bucket
+        assert_raise(Aws::AwsError) { @s3.delete_bucket(@bucket) }
+        assert @s3.clear_bucket(@bucket), 'Clear_bucket fail'
+        assert_equal 0, @s3.list_bucket(@bucket).size, 'Bucket must be empty'
+        assert @s3.delete_bucket(@bucket)
+        assert !@s3.list_all_my_buckets.map{|bucket| bucket[:name]}.include?(@bucket), "#{@bucket} must not exist"
+    end
+
+
+    #---------------------------
+    # Aws::S3 classes
+    #---------------------------
+
+    def test_20_s3
+        # create bucket
+        bucket = @s.bucket(@bucket, true)
+        assert bucket
+        # check that the bucket exists
+        assert @s.buckets.map{|b| b.name}.include?(@bucket)
+        # delete bucket
+        assert bucket.clear
+        assert bucket.delete
+    end
+
+    def test_21_bucket_create_put_get_key
+        bucket = Aws::S3::Bucket.create(@s, @bucket, true)
+        # check that the bucket exists
+        assert @s.buckets.map{|b| b.name}.include?(@bucket)
+        assert bucket.keys.empty?
+        # put data
+        assert bucket.put(@key3, RIGHT_OBJECT_TEXT, {'family'=>'123456'})
+        # get data and compare
+        assert_equal RIGHT_OBJECT_TEXT, bucket.get(@key3)
+        # get key object
+        key = bucket.key(@key3, true)
+        assert_equal Aws::S3::Key, key.class
+        assert key.exists?
+        assert_equal '123456', key.meta_headers['family']
+    end
+
+    def test_22_keys
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # create first key
+        key3 = Aws::S3::Key.create(bucket, @key3)
+        key3.refresh
+        assert key3.exists?
+        assert_equal '123456', key3.meta_headers['family']
+        # create second key
+        key2 = Aws::S3::Key.create(bucket, @key2)
+        assert !key2.refresh
+        assert !key2.exists?
+        assert_raise(Aws::AwsError) { key2.head }
+        # store key
+        key2.meta_headers = {'family'=>'111222333'}
+        assert key2.put(RIGHT_OBJECT_TEXT)
+        # make sure that the key exists
+        assert key2.refresh
+        assert key2.exists?
+        assert key2.head
+        # get its data
+        assert_equal RIGHT_OBJECT_TEXT, key2.get
+        # drop key
+        assert key2.delete
+        assert !key2.exists?
+    end
+
+    def test_23_rename_key
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # -- 1 -- (key based rename)
+        # create a key
+        key = bucket.key('test/copy/1')
+        key.put(RIGHT_OBJECT_TEXT)
+        original_key = key.clone
+        assert key.exists?, "'test/copy/1' should exist"
+        # rename it
+        key.rename('test/copy/2')
+        assert_equal 'test/copy/2', key.name
+        assert key.exists?, "'test/copy/2' should exist"
+        # the original key should not exist
+        assert !original_key.exists?, "'test/copy/1' should not exist"
+        # -- 2 -- (bucket based rename)
+        bucket.rename_key('test/copy/2', 'test/copy/3')
+        assert bucket.key('test/copy/3').exists?, "'test/copy/3' should exist"
+        assert !bucket.key('test/copy/2').exists?, "'test/copy/2' should not exist"
+    end
+
+    def test_24_copy_key
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # -- 1 -- (key based copy)
+        # create a key
+        key = bucket.key('test/copy/10')
+        key.put(RIGHT_OBJECT_TEXT)
+        # make copy
+        new_key = key.copy('test/copy/11')
+        # make sure both the keys exist and have a correct data
+        assert key.exists?,     "'test/copy/10' should exist"
+        assert new_key.exists?, "'test/copy/11' should exist"
+        assert_equal RIGHT_OBJECT_TEXT, key.get
+        assert_equal RIGHT_OBJECT_TEXT, new_key.get
+        # -- 2 -- (bucket based copy)
+        bucket.copy_key('test/copy/11', 'test/copy/12')
+        assert bucket.key('test/copy/11').exists?, "'test/copy/11' should exist"
+        assert bucket.key('test/copy/12').exists?, "'test/copy/12' should exist"
+        assert_equal RIGHT_OBJECT_TEXT, bucket.key('test/copy/11').get
+        assert_equal RIGHT_OBJECT_TEXT, bucket.key('test/copy/12').get
+    end
+
+    def test_25_move_key
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # -- 1 -- (key based copy)
+        # create a key
+        key = bucket.key('test/copy/20')
+        key.put(RIGHT_OBJECT_TEXT)
+        # move
+        new_key = key.move('test/copy/21')
+        # make sure both the keys exist and have a correct data
+        assert !key.exists?,    "'test/copy/20' should not exist"
+        assert new_key.exists?, "'test/copy/21' should exist"
+        assert_equal RIGHT_OBJECT_TEXT, new_key.get
+        # -- 2 -- (bucket based copy)
+        bucket.copy_key('test/copy/21', 'test/copy/22')
+        assert bucket.key('test/copy/21').exists?, "'test/copy/21' should not exist"
+        assert bucket.key('test/copy/22').exists?, "'test/copy/22' should exist"
+        assert_equal RIGHT_OBJECT_TEXT, bucket.key('test/copy/22').get
+    end
+
+    def test_26_save_meta
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # create a key
+        key = bucket.key('test/copy/30')
+        key.put(RIGHT_OBJECT_TEXT)
+        assert key.meta_headers.blank?
+        # store some meta keys
+        meta = {'family' => 'oops', 'race' => 'troll'}
+        assert_equal meta, key.save_meta(meta)
+        # reload meta
+        assert_equal meta, key.reload_meta
+    end
+
+    def test_27_clear_delete
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # add another key
+        bucket.put(@key2, RIGHT_OBJECT_TEXT)
+        # delete 'folder'
+        assert_equal 1, bucket.delete_folder(@key1).size
+        # delete
+        assert_raise(Aws::AwsError) { bucket.delete }
+        bucket.delete(true)
+    end
+
+    # Grantees
+
+    def test_30_create_bucket
+        bucket = @s.bucket(@bucket, true, 'public-read')
+        assert bucket
+    end
+
+    def test_31_list_grantees
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # get grantees list
+        grantees = bucket.grantees
+        # check that the grantees count equal to 2 (root, AllUsers)
+        assert_equal 2, grantees.size
+    end
+
+    def test_32_grant_revoke_drop
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # Take 'AllUsers' grantee
+        grantee = Aws::S3::Grantee.new(bucket, 'http://acs.amazonaws.com/groups/global/AllUsers')
+        # Check exists?
+        assert grantee.exists?
+        # Add grant as String
+        assert grantee.grant('WRITE')
+        # Add grants as Array
+        assert grantee.grant(['READ_ACP', 'WRITE_ACP'])
+        # Check perms count
+        assert_equal 4, grantee.perms.size
+        # revoke 'WRITE_ACP'
+        assert grantee.revoke('WRITE_ACP')
+        # Check manual perm removal method
+        grantee.perms -= ['READ_ACP']
+        grantee.apply
+        assert_equal 2, grantee.perms.size
+        # Check grantee removal if it has no permissions
+        assert grantee.perms = []
+        assert grantee.apply
+        assert !grantee.exists?
+        # Check multiple perms assignment
+        assert grantee.grant('FULL_CONTROL', 'READ', 'WRITE')
+        assert_equal ['FULL_CONTROL', 'READ', 'WRITE'].sort, grantee.perms.sort
+        # Check multiple perms removal
+        assert grantee.revoke('FULL_CONTROL', 'WRITE')
+        assert_equal ['READ'], grantee.perms
+        # check 'Drop' method
+        assert grantee.drop
+        assert !grantee.exists?
+        assert_equal 1, bucket.grantees.size
+        # Delete bucket
+        bucket.delete(true)
+    end
+
+    def test_33_key_grantees
+        # Create bucket
+        bucket = @s.bucket(@bucket, true)
+        # Create key
+        key = bucket.key(@key1)
+        assert key.put(RIGHT_OBJECT_TEXT, 'public-read')
+        # Get grantees list (must be == 2)
+        grantees = key.grantees
+        assert grantees
+        assert_equal 2, grantees.size
+        # Take one of grantees and give him 'Write' perms
+        grantee = grantees[0]
+        assert grantee.grant('WRITE')
+        # Drop grantee
+        assert grantee.drop
+        # Drop bucket
+        bucket.delete(true)
+    end
+
+    def test_34_bucket_create_put_with_perms
+        bucket = Aws::S3::Bucket.create(@s, @bucket, true)
+        # check that the bucket exists
+        assert @s.buckets.map{|b| b.name}.include?(@bucket)
+        assert bucket.keys.empty?
+        # put data (with canned ACL)
+        assert bucket.put(@key1, RIGHT_OBJECT_TEXT, {'family'=>'123456'}, "public-read")
+        # get data and compare
+        assert_equal RIGHT_OBJECT_TEXT, bucket.get(@key1)
+        # get key object
+        key = bucket.key(@key1, true)
+        assert_equal Aws::S3::Key, key.class
+        assert key.exists?
+        assert_equal '123456', key.meta_headers['family']
+    end
+
+    def test_35_key_put_with_perms
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        # create first key
+        key1 = Aws::S3::Key.create(bucket, @key1)
+        key1.refresh
+        assert key1.exists?
+        assert key1.put(RIGHT_OBJECT_TEXT, "public-read")
+        # get its data
+        assert_equal RIGHT_OBJECT_TEXT, key1.get
+        # drop key
+        assert key1.delete
+        assert !key1.exists?
+    end
+
+    def test_36_set_amazon_problems
+        original_problems = Aws::S3Interface.amazon_problems
+        assert(original_problems.length > 0)
+        Aws::S3Interface.amazon_problems= original_problems << "A New Problem"
+        new_problems = Aws::S3Interface.amazon_problems
+        assert_equal(new_problems, original_problems)
+
+        Aws::S3Interface.amazon_problems= nil
+        assert_nil(Aws::S3Interface.amazon_problems)
+    end
+
+    def test_37_access_logging
+        bucket = Aws::S3::Bucket.create(@s, @bucket, false)
+        targetbucket = Aws::S3::Bucket.create(@s, @bucket2, true)
+        # Take 'AllUsers' grantee
+        grantee = Aws::S3::Grantee.new(targetbucket, 'http://acs.amazonaws.com/groups/s3/LogDelivery')
+
+        assert grantee.grant(['READ_ACP', 'WRITE'])
+
+        assert bucket.enable_logging(:targetbucket => targetbucket, :targetprefix => "loggylogs/")
+
+        assert_equal(bucket.logging_info, {:enabled => true, :targetbucket => @bucket2, :targetprefix => "loggylogs/"})
+
+        assert bucket.disable_logging
+
+        # check 'Drop' method
+        assert grantee.drop
+
+        # Delete bucket
+        bucket.delete(true)
+        targetbucket.delete(true)
+    end
+
+end