aws 1.11.38 → 2.1.0

data/lib/sqs/right_sqs_interface.rb

@@ -21,10 +21,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-module RightAws
+module Aws
 
   #
-  # Right::Aws::SqsGen2Interface - RightScale's low-level Amazon SQS interface
+  # Right::Aws::SqsInterface - RightScale's low-level Amazon SQS interface
   # for API version 2008-01-01 and later.
   # For explanations of the semantics
   # of each call, please refer to Amazon's documentation at
@@ -33,10 +33,10 @@ module RightAws
   # This class provides a procedural interface to SQS.  Conceptually it is
   # mostly a pass-through interface to SQS and its API is very similar to the
   # bare SQS API.  For a somewhat higher-level and object-oriented interface, see
-  # RightAws::SqsGen2.
+  # Aws::Sqs.
 
-  class SqsInterface < RightAwsBase
-    include RightAwsBaseInterface
+  class SqsInterface < AwsBase
+    include AwsBaseInterface
 
     API_VERSION       = "2008-01-01"
     DEFAULT_HOST      = "queue.amazonaws.com"
@@ -65,7 +65,7 @@ module RightAws
     # Amazon's article "Migrating to Amazon SQS API version 2008-01-01" at:
     # http://developer.amazonwebservices.com/connect/entry.jspa?externalID=1148
     #
-    #  sqs = RightAws::SqsGen2Interface.new('1E3GDYEOGFJPIT75KDT40','hgTHt68JY07JKUY08ftHYtERkjgtfERn57DFE379', {:multi_thread => true, :logger => Logger.new('/tmp/x.log')})
+    #  sqs = Aws::SqsInterface.new('1E3GDYEOGFJPIT75KDT40','hgTHt68JY07JKUY08ftHYtERkjgtfERn57DFE379', {:multi_thread => true, :logger => Logger.new('/tmp/x.log')})
     #
     # Params is a hash:
     #
@@ -367,7 +367,7 @@ module RightAws
     #      PARSERS: Status Response Parser
     #-----------------------------------------------------------------
 
-    class SqsStatusParser < RightAWSParser # :nodoc:
+    class SqsStatusParser < AwsParser # :nodoc:
       def tagend(name)
         if name == 'ResponseMetadata'
           @result = true
@@ -379,13 +379,13 @@ module RightAws
     #      PARSERS: Queue
     #-----------------------------------------------------------------
 
-    class SqsCreateQueueParser < RightAWSParser # :nodoc:
+    class SqsCreateQueueParser < AwsParser # :nodoc:
       def tagend(name)
         @result = @text if name == 'QueueUrl'
       end
     end
 
-    class SqsListQueuesParser < RightAWSParser # :nodoc:
+    class SqsListQueuesParser < AwsParser # :nodoc:
       def reset
         @result = []
       end
@@ -394,7 +394,7 @@ module RightAws
       end
     end
 
-    class SqsGetQueueAttributesParser < RightAWSParser # :nodoc:
+    class SqsGetQueueAttributesParser < AwsParser # :nodoc:
       def reset
         @result = {}
       end
@@ -410,7 +410,7 @@ module RightAws
     #      PARSERS: Messages
     #-----------------------------------------------------------------
 
-    class SqsReceiveMessageParser < RightAWSParser # :nodoc:
+    class SqsReceiveMessageParser < AwsParser # :nodoc:
       def reset
         @result = []
       end
@@ -427,7 +427,7 @@ module RightAws
       end
     end
 
-    class SqsSendMessagesParser < RightAWSParser # :nodoc:
+    class SqsSendMessagesParser < AwsParser # :nodoc:
       def reset
         @result = {}
       end

data/test/acf/test_right_acf.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
 
 class TestAcf < Test::Unit::TestCase
 
@@ -7,15 +8,16 @@ class TestAcf < Test::Unit::TestCase
   STDOUT.sync = true
 
   def setup
-    @acf= Rightscale::AcfInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
-    @s3 = Rightscale::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+      TestCredentials.get_credentials
+    @acf= Aws::AcfInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+    @s3 = Aws::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
     @bucket_name   = "right-acf-awesome-test-bucket-0001"
     @bucket_domain = "#{@bucket_name}.s3.amazonaws.com"
   end
 
   def test_01_list_distributions_part1
     distributions = nil
-    assert_nothing_raised(Rightscale::AwsError) do
+    assert_nothing_raised(Aws::AwsError) do
       distributions = @acf.list_distributions
     end
     assert distributions.is_a?(Array)
@@ -23,13 +25,13 @@ class TestAcf < Test::Unit::TestCase
 
   def test_02_try_to_create_for_bad_bucket
     # a bucket does not exist
-    assert_raise(Rightscale::AwsError) do
+    assert_raise(Aws::AwsError) do
       @acf.create_distribution("right-cloudfront-awesome-test-bucket-not-exist", "Mustn't to be born", true)
     end
     # a bucket is not a domain naming complied guy
     bucket_name = 'right_cloudfront_awesome_test_bucket_BAD'
     @s3.bucket(bucket_name, :create)
-    assert_raise(Rightscale::AwsError) do
+    assert_raise(Aws::AwsError) do
       @acf.create_distribution(bucket_name, "Mustn't to be born", true)
     end
   end
@@ -87,7 +89,7 @@ class TestAcf < Test::Unit::TestCase
     assert_not_equal config[:e_tag], new_config[:e_tag]
 
     # try to update the old config again (must fail because ETAG has changed)
-    assert_raise(Rightscale::AwsError) do
+    assert_raise(Aws::AwsError) do
       @acf.set_distribution_config(old[:aws_id], config)
     end
   end
@@ -98,7 +100,7 @@ class TestAcf < Test::Unit::TestCase
     # list distributions
     @acf.list_distributions
     # list the distributions again - cache should hit
-    assert_raise(Rightscale::AwsNoChange) do
+    assert_raise(Aws::AwsNoChange) do
       @acf.list_distributions
     end
     # disable caching
@@ -112,7 +114,7 @@ class TestAcf < Test::Unit::TestCase
     # should fail because
     if distribution[:status] == 'InProgress'
       # should fail because the distribution is not deployed yet
-      assert_raise(Rightscale::AwsError) do
+      assert_raise(Aws::AwsError) do
         @acf.delete_distribution(distribution[:aws_id], distribution[:e_tag])
       end
       # wait for a deployed state

data/test/ec2/test_helper.rb

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

data/test/ec2/test_mon.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+require 'pp'
+
+class TestEc2 < 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
+        @ec2 = Aws::Ec2.new(TestCredentials.aws_access_key_id,
+                                   TestCredentials.aws_secret_access_key)
+        @key = 'right_ec2_awesome_test_key'
+        @group = 'right_ec2_awesome_test_security_group'
+    end
+end

data/test/ec2/test_right_ec2.rb

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 require 'pp'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
 
 class TestEc2 < Test::Unit::TestCase
 
@@ -7,7 +8,8 @@ class TestEc2 < Test::Unit::TestCase
     # are not tested here due to their potentially risk.
   
   def setup
-    @ec2   = Rightscale::Ec2.new(TestCredentials.aws_access_key_id,
+      TestCredentials.get_credentials
+    @ec2   = Aws::Ec2.new(TestCredentials.aws_access_key_id,
                                  TestCredentials.aws_secret_access_key)
     @key   = 'right_ec2_awesome_test_key'
     @group = 'right_ec2_awesome_test_security_group'
@@ -45,13 +47,13 @@ class TestEc2 < Test::Unit::TestCase
     images = @ec2.describe_images
     assert images.size>0, 'Amazon must have at least some public images'
       # unknown image
-    assert_raise(Rightscale::AwsError){ @ec2.describe_images(['ami-ABCDEFGH'])}
+    assert_raise(Aws::AwsError){ @ec2.describe_images(['ami-ABCDEFGH'])}
   end
 
   def test_07_describe_instanses
     assert @ec2.describe_instances
       # unknown image
-    assert_raise(Rightscale::AwsError){ @ec2.describe_instances(['i-ABCDEFGH'])}
+    assert_raise(Aws::AwsError){ @ec2.describe_instances(['i-ABCDEFGH'])}
   end
 
   def test_08_delete_security_group
@@ -62,11 +64,11 @@ class TestEc2 < Test::Unit::TestCase
     assert @ec2.delete_key_pair(@key), 'Delete_key_pair fail'
 ##  Hmmm... Amazon does not through the exception any more. It now just returns a 'true' if the key does not exist any more...
 ##      # key must be deleted already
-##    assert_raise(Rightscale::AwsError) { @ec2.delete_key_pair(@key) }
+##    assert_raise(Aws::AwsError) { @ec2.delete_key_pair(@key) }
   end
 
   def test_10_signature_version_0
-    ec2 = Rightscale::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :signature_version => '0')
+    ec2 = Aws::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :signature_version => '0')
     images = ec2.describe_images
     assert images.size>0, 'Amazon must have at least some public images'
     # check that the request has correct signature version
@@ -82,7 +84,7 @@ class TestEc2 < Test::Unit::TestCase
     assert regions.size > 0
     # check an access to regions
     regions.each do |region|
-      regional_ec2 = Rightscale::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :region => region)
+      regional_ec2 = Aws::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :region => region)
       # do we have a correct endpoint server?
       assert_equal "#{region}.ec2.amazonaws.com", regional_ec2.params[:server]
       # get a list of images from every region
@@ -96,7 +98,7 @@ class TestEc2 < Test::Unit::TestCase
   end
   
   def test_12_endpoint_url
-    ec2 = Rightscale::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :endpoint_url => 'a://b.c:0/d/', :region => 'z')
+    ec2 = Aws::Ec2.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :endpoint_url => 'a://b.c:0/d/', :region => 'z')
     # :endpoint_url has a priority hence :region should be ommitted
     assert_equal 'a',   ec2.params[:protocol]
     assert_equal 'b.c', ec2.params[:server]

data/test/s3/test_helper.rb

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

data/test/s3/test_right_s3.rb

@@ -1,419 +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
-    @s3     = Rightscale::S3Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
-    @bucket = 'right_s3_awesome_test_bucket_000A1'
-    @bucket2 = 'right_s3_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      = Rightscale::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
-  end
-
-  #---------------------------
-  # Rightscale::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(Rightscale::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(Rightscale::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(Rightscale::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(Rightscale::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
-  
-  
-  
-
-  #---------------------------
-  # Rightscale::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 = Rightscale::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 Rightscale::S3::Key, key.class
-    assert       key.exists?
-    assert_equal '123456', key.meta_headers['family']
-  end
-
-  def test_22_keys
-    bucket = Rightscale::S3::Bucket.create(@s, @bucket, false)
-      # create first key
-    key3 = Rightscale::S3::Key.create(bucket, @key3)
-    key3.refresh
-    assert key3.exists?
-    assert_equal '123456', key3.meta_headers['family']
-      # create second key
-    key2 = Rightscale::S3::Key.create(bucket, @key2)
-    assert !key2.refresh
-    assert !key2.exists?
-    assert_raise(Rightscale::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 = Rightscale::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 = Rightscale::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 = Rightscale::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 = Rightscale::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 = Rightscale::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(Rightscale::AwsError) { bucket.delete }
-    bucket.delete(true)
-  end
+    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 = Rightscale::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 = Rightscale::S3::Bucket.create(@s, @bucket, false)
-      # Take 'AllUsers' grantee 
-    grantee = Rightscale::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 = Rightscale::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 Rightscale::S3::Key, key.class
-    assert       key.exists?
-    assert_equal '123456', key.meta_headers['family']
-  end
-
-  def test_35_key_put_with_perms
-    bucket = Rightscale::S3::Bucket.create(@s, @bucket, false)
-      # create first key
-    key1 = Rightscale::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 = RightAws::S3Interface.amazon_problems
-    assert(original_problems.length > 0)
-    RightAws::S3Interface.amazon_problems= original_problems << "A New Problem"
-    new_problems = RightAws::S3Interface.amazon_problems
-    assert_equal(new_problems, original_problems)
-
-    RightAws::S3Interface.amazon_problems= nil
-    assert_nil(RightAws::S3Interface.amazon_problems)
-  end
-  
-  def test_37_access_logging
-    bucket = Rightscale::S3::Bucket.create(@s, @bucket, false)
-    targetbucket = Rightscale::S3::Bucket.create(@s, @bucket2, true)
-      # Take 'AllUsers' grantee 
-    grantee = Rightscale::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
+
+    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