dmarkov-right_aws 1.10.0

data/test/acf/test_helper.rb

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

data/test/acf/test_right_acf.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestAcf < Test::Unit::TestCase
+
+  RIGHT_OBJECT_TEXT     = 'Right test message'
+  
+  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)
+    @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
+      distributions = @acf.list_distributions
+    end
+    assert distributions.is_a?(Array)
+  end
+
+  def test_02_try_to_create_for_bad_bucket
+    # a bucket does not exist
+    assert_raise(Rightscale::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
+      @acf.create_distribution(bucket_name, "Mustn't to be born", true)
+    end
+  end
+
+  def test_03_create
+    comment = 'WooHoo!!!'
+    # create a test bucket
+    @s3.bucket(@bucket_name, :create)
+    # create a distribution
+    distribution = @acf.create_distribution(@bucket_domain, comment, true)
+    assert_equal comment, distribution[:comment]
+    assert       distribution[:cnames].size == 0
+    assert       distribution[:enabled]
+  end
+
+  def test_04_list_distributions_part2
+    distributions = @acf.list_distributions
+    assert distributions.size > 0
+  end
+
+  def get_test_distribution
+    @acf.list_distributions.select{ |d| d[:origin] == @bucket_domain }.first
+  end
+
+  def test_05_get_distribution
+    old = get_test_distribution
+    assert_nothing_raised do
+      @acf.get_distribution(old[:aws_id])
+    end
+  end
+
+  def test_06_get_and_set_config
+    config = nil
+    old = get_test_distribution
+    assert_nothing_raised do
+      config = @acf.get_distribution_config(old[:aws_id])
+    end
+    # change a config
+    config[:enabled] = false
+    config[:cnames] << 'x1.myawesomesite.com'
+    config[:cnames] << 'x2.myawesomesite.com'
+    # set config
+    set_config_result = nil
+    assert_nothing_raised do
+      set_config_result = @acf.set_distribution_config(old[:aws_id], config)
+    end
+    assert set_config_result
+    # reget the config and check
+    new_config = nil
+    assert_nothing_raised do
+      new_config = @acf.get_distribution_config(old[:aws_id])
+    end
+    assert           !new_config[:enabled]
+    assert_equal     new_config[:cnames].sort, ['x1.myawesomesite.com', 'x2.myawesomesite.com']
+    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
+      @acf.set_distribution_config(old[:aws_id], config)
+    end
+  end
+
+  def test_07_caching
+    # enable caching
+    @acf.params[:cache] = true
+    # list distributions
+    @acf.list_distributions
+    # list the distributions again - cache should hit
+    assert_raise(Rightscale::AwsNoChange) do
+      @acf.list_distributions
+    end
+    # disable caching
+    @acf.params[:cache] = true
+  end
+
+  def test_08_delete_distribution
+    # we need ETAG so use get_distribution
+    distribution = @acf.get_distribution(get_test_distribution[:aws_id])
+    # try to delete a distribution
+    # should fail because
+    if distribution[:status] == 'InProgress'
+      # should fail because the distribution is not deployed yet
+      assert_raise(Rightscale::AwsError) do
+        @acf.delete_distribution(distribution[:aws_id], distribution[:e_tag])
+      end
+      # wait for a deployed state
+      print "waiting up to 5 min while the distribution is being deployed: "
+      100.times do
+        print '.'
+        distribution = @acf.get_distribution(distribution[:aws_id])
+        if distribution[:status] == 'Deployed'
+          print ' done'
+          break
+        end
+        sleep 3
+      end
+      puts
+    end
+
+    # only disabled and deployed distribution can be deleted
+    assert_equal 'Deployed', distribution[:status]
+    assert       !distribution[:enabled]
+
+    # delete the distribution
+    assert_nothing_raised do
+      @acf.delete_distribution(distribution[:aws_id], distribution[:e_tag])
+    end  
+  end
+
+  def test_09_drop_bucket
+    assert @s3.bucket(@bucket_name).delete
+  end
+
+end

data/test/ec2/test_helper.rb

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

data/test/ec2/test_right_ec2.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper.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
+    @ec2   = Rightscale::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
+  
+  def test_01_create_describe_key_pairs
+    new_key = @ec2.create_key_pair(@key)
+    assert new_key[:aws_material][/BEGIN RSA PRIVATE KEY/], "New key material is absent"
+    keys = @ec2.describe_key_pairs
+    assert keys.map{|key| key[:aws_key_name] }.include?(@key), "#{@key} must exist"
+  end
+  
+  def test_02_create_security_group
+    assert @ec2.create_security_group(@group,'My awesone test group'), 'Create_security_group fail'
+    group = @ec2.describe_security_groups([@group])[0]
+    assert_equal @group, group[:aws_group_name], 'Group must be created but does not exist'
+  end
+  
+  def test_03_perms_add
+    assert @ec2.authorize_security_group_named_ingress(@group, TestCredentials.account_number, 'default')
+    assert @ec2.authorize_security_group_IP_ingress(@group, 80,80,'udp','192.168.1.0/8')
+  end
+  
+  def test_04_check_new_perms_exist
+    assert_equal 2, @ec2.describe_security_groups([@group])[0][:aws_perms].size
+  end
+
+  def test_05_perms_remove
+    assert @ec2.revoke_security_group_IP_ingress(@group, 80,80,'udp','192.168.1.0/8')
+    assert @ec2.revoke_security_group_named_ingress(@group,
+                                                    TestCredentials.account_number, 'default')
+  end
+
+  def test_06_describe_images
+    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'])}
+  end
+
+  def test_07_describe_instanses
+    assert @ec2.describe_instances
+      # unknown image
+    assert_raise(Rightscale::AwsError){ @ec2.describe_instances(['i-ABCDEFGH'])}
+  end
+
+  def test_08_delete_security_group
+    assert @ec2.delete_security_group(@group), 'Delete_security_group fail'
+  end
+  
+  def test_09_delete_key_pair
+    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) }
+  end
+
+  def test_10_signature_version_0
+    ec2 = Rightscale::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
+    assert ec2.last_request.path.include?('SignatureVersion=0')
+  end
+
+  def test_11_regions
+    regions = nil
+    assert_nothing_raised do
+      regions = @ec2.describe_regions
+    end
+    # check we got more that 0 regions
+    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)
+      # 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
+      images = nil
+      assert_nothing_raised do
+        images = regional_ec2.describe_regions
+      end
+      # every region must have images
+      assert images.size > 0
+    end
+  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')
+    # :endpoint_url has a priority hence :region should be ommitted
+    assert_equal 'a',   ec2.params[:protocol]
+    assert_equal 'b.c', ec2.params[:server]
+    assert_equal '/d/', ec2.params[:service]
+    assert_equal 0,     ec2.params[:port]
+    assert_nil          ec2.params[:region]
+  end
+
+end

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/s3/test_helper.rb

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

data/test/s3/test_right_s3.rb

@@ -0,0 +1,419 @@
+require File.dirname(__FILE__) + '/test_helper.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
+
+    # 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
+
+end