aboisvert_aws 3.0.0

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_helper.rb

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

data/test/rds/test_right_rds.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRds < Test::Unit::TestCase
+
+  STDOUT.sync = true
+
+  TEST_SG_NAME = 'RightRdsSGTest0123456789'
+
+  def setup
+    @rds = Rightscale::RdsInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :logger => Logger.new('/dev/null'))
+  end
+
+  def test_00_instances
+    assert_nothing_raised do
+      items = @rds.describe_db_instances
+      assert items.is_a?(Array)
+    end
+    #
+    assert_nothing_raised do
+      @rds.describe_db_instances do |response|
+        assert response.is_a?(Hash)
+        assert response[:db_instances].is_a?(Array)
+      end
+    end
+  end
+
+  def test_10_security_groups
+    assert_nothing_raised do
+      items = @rds.describe_db_security_groups
+      assert items.is_a?(Array)
+    end
+    #
+    assert_nothing_raised do
+      @rds.describe_db_security_groups do |response|
+        assert response.is_a?(Hash)
+        assert response[:db_security_groups].is_a?(Array)
+      end
+    end
+  end
+
+  def test_11_remove_security_group
+    @rds.delete_db_security_group rescue nil
+  end
+
+  def test_12_create_security_group
+    sg = nil
+    assert_nothing_raised do
+      sg = @rds.create_db_security_group(TEST_SG_NAME, 'sg-description')
+    end
+    assert sg.is_a?(Hash)
+  end
+
+  def test_13_authorize
+    assert_nothing_raised do
+      sg = @rds.authorize_db_security_group_ingress(TEST_SG_NAME, :cidrip => '131.0.0.1/8')
+      assert sg.is_a?(Hash)
+      assert_equal 1, sg[:ip_ranges].size
+    end
+    assert_nothing_raised do
+      sg = @rds.authorize_db_security_group_ingress(TEST_SG_NAME, :ec2_security_group_owner => '826693181925',
+                                                                  :ec2_security_group_name  => 'default' )
+      assert sg.is_a?(Hash)
+      assert_equal 1, sg[:ec2_security_groups].size
+    end
+    sleep 30
+  end
+
+  def test_14_revoke
+    assert_nothing_raised do
+      sg = @rds.revoke_db_security_group_ingress(TEST_SG_NAME, :cidrip => '131.0.0.1/8')
+      assert sg.is_a?(Hash)
+    end
+    assert_nothing_raised do
+      sg = @rds.revoke_db_security_group_ingress(TEST_SG_NAME, :ec2_security_group_owner => '826693181925',
+                                                               :ec2_security_group_name  => 'default' )
+      assert sg.is_a?(Hash)
+    end
+    sleep 30
+    #
+    sg = @rds.describe_db_security_groups(TEST_SG_NAME).first
+    assert_equal 0, sg[:ip_ranges].size
+    assert_equal 0, sg[:ec2_security_groups].size
+  end
+
+  def test_15_delete_security_group
+    assert_nothing_raised do
+      @rds.delete_db_security_group(TEST_SG_NAME)
+    end
+  end
+
+
+  def test_20_db_snapshots
+    assert_nothing_raised do
+      items = @rds.describe_db_snapshots
+      assert items.is_a?(Array)
+    end
+    #
+    assert_nothing_raised do
+      @rds.describe_db_snapshots do |response|
+        assert response.is_a?(Hash)
+        assert response[:db_snapshots].is_a?(Array)
+      end
+    end
+  end
+
+  def test_30_events
+    assert_nothing_raised do
+      items = @rds.describe_events
+      assert items.is_a?(Array)
+    end
+    #
+    assert_nothing_raised do
+      @rds.describe_events do |response|
+        assert response.is_a?(Hash)
+        assert response[:events].is_a?(Array)
+      end
+    end
+  end
+
+end

data/test/route_53/fixtures/a_record.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/2011-05-05/">
+  <ChangeBatch>
+    <Changes>
+      <Change>
+        <Action>CREATE</Action>
+        <ResourceRecordSet>
+          <Name>host.right-aws.example.com.</Name>
+          <Type>A</Type>
+          <TTL>600</TTL>
+          <ResourceRecords>
+            <ResourceRecord><Value>10.0.0.1</Value></ResourceRecord>
+          </ResourceRecords>
+        </ResourceRecordSet>
+      </Change>
+    </Changes>
+  </ChangeBatch>
+</ChangeResourceRecordSetsRequest>

data/test/route_53/fixtures/alias_record.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/2011-05-05/">
+  <ChangeBatch>
+    <Changes>
+      <Change>
+        <Action>CREATE</Action>
+        <ResourceRecordSet>
+          <Name>right-aws.example.com.</Name>
+          <Type>A</Type>
+          <AliasTarget>
+            <HostedZoneId>Z1234567890123</HostedZoneId>
+            <DNSName>example-load-balancer-1111111111.us-east-1.elb.amazonaws.com.</DNSName>
+          </AliasTarget>
+        </ResourceRecordSet>
+      </Change>
+    </Changes>
+  </ChangeBatch>
+</ChangeResourceRecordSetsRequest>

data/test/route_53/test_helper.rb

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

data/test/route_53/test_right_route_53.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRoute53 < Test::Unit::TestCase
+
+  STDOUT.sync = true
+  BALANCER_NAME = 'right-aws-test-lb'
+
+  def setup
+    @r53 = Rightscale::Route53Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :logger => Logger.new('/dev/null'))
+    @zone_config = {:name => "right-aws.example.com.", :config => {:comment => 'a comment'}}
+
+    @elb = Rightscale::ElbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :logger => Logger.new('/dev/null'))
+  end
+
+  def teardown
+    @r53.list_hosted_zones.each do |zone|
+      next unless zone[:name] == @zone_config[:name]
+      zone_id = zone[:aws_id]
+      puts zone_id
+      records = @r53.list_resource_record_sets(zone_id)
+      # The NS and SOA records are provided by AWS and must not be deleted
+      records.reject! { |rr| %w[NS SOA].include? rr[:type] }
+      if records.any?
+        response = @r53.delete_resource_record_sets(zone_id, records)
+        puts response.inspect
+      end
+      puts @r53.delete_hosted_zone(zone_id).inspect
+    end
+    # Uncomment to shut down at the end of the day.
+    # @elb.delete_load_balancer BALANCER_NAME
+  end
+
+  def test_00_list_hosted_zones
+    items = @r53.list_hosted_zones
+    assert items.is_a?(Array)
+  end
+
+  def test_create_and_delete_zone
+    response = @r53.create_hosted_zone(@zone_config)
+    assert_equal response[:name], @zone_config[:name]
+    assert response[:aws_id].is_a?(String)
+    assert response[:name_servers].is_a?(Array)
+
+    response2 = @r53.delete_hosted_zone(response[:aws_id])
+    assert_equal response2[:status], 'PENDING'
+  end
+
+  def test_add_and_remove_A_record
+    zone = @r53.create_hosted_zone(@zone_config)
+    zone_id = zone[:aws_id]
+    # add
+    a_record = { :name => 'host.right-aws.example.com.', :type => 'A', :ttl => 600, :resource_records => ['10.0.0.1'] }
+    response = @r53.create_resource_record_sets(zone_id, [a_record.dup]) # .dup since it will get :action => :create
+    assert_equal response[:status], 'PENDING'
+
+    # It should be there now
+    records = @r53.list_resource_record_sets(zone_id)
+    assert records.is_a?(Array)
+    assert records.detect { |rr| rr == a_record }, "Could not find '#{a_record.inspect}' in '#{records.inspect}'"
+
+    # remove
+    response = @r53.delete_resource_record_sets(zone_id, [a_record.dup])
+    assert_equal response[:status], 'PENDING'
+
+    # It should not be there anymore
+    records = @r53.list_resource_record_sets(zone_id)
+    assert records.is_a?(Array)
+    assert ! records.detect { |rr| rr == a_record }, "Record '#{a_record.inspect}' is still in '#{records.inspect}'"
+
+    @r53.delete_hosted_zone(zone_id)
+  end
+
+  def test_add_and_remove_Alias_record
+    lb = find_or_create_load_balancer
+
+    zone = @r53.create_hosted_zone(@zone_config)
+    zone_id = zone[:aws_id]
+
+    # add
+    alias_target = { :hosted_zone_id => lb[:canonical_hosted_zone_name_id], :dns_name => lb[:dns_name] }
+    alias_record = { :name => 'right-aws.example.com', :type => 'A', :alias_target => alias_target }
+    response = @r53.create_resource_record_sets(zone_id, [alias_record.dup]) # .dup since it will get :action => :create
+    assert_equal response[:status], 'PENDING'
+
+    # It should be there now
+    records = @r53.list_resource_record_sets(zone_id)
+    assert records.is_a?(Array)
+    record = records.detect { |rr| rr[:alias_target] }
+    assert record, "Could not find '#{alias_record.inspect}' in '#{records.inspect}'"
+    # AWS adds final dots to names
+    assert_equal "#{alias_record[:name]}.", record[:name]
+    assert_equal "#{alias_target[:dns_name]}.", record[:alias_target][:dns_name]
+
+    # remove
+    response = @r53.delete_resource_record_sets(zone_id, [alias_record.dup])
+    assert_equal response[:status], 'PENDING'
+
+    # It should not be there anymore
+    records = @r53.list_resource_record_sets(zone_id)
+    assert records.is_a?(Array)
+    record = records.detect { |rr| rr[:alias_target] }
+    assert ! record, "Record '#{alias_record.inspect}' is still in '#{records.inspect}'"
+
+    @r53.delete_hosted_zone(zone_id)
+  end
+
+  def find_or_create_load_balancer
+    unless @elb.describe_load_balancers.detect { |lb| lb[:load_balancer_name] == BALANCER_NAME }
+      @elb.create_load_balancer(BALANCER_NAME, %w[us-east-1b], [])
+      puts "WARNING: Started load balancer.  Remember to shut it down (see teardown)."
+      puts "NOTE: Tests might not pass during first few seconds after load balancer is created."
+    end
+    @elb.describe_load_balancers.detect { |lb| lb[:load_balancer_name] == BALANCER_NAME }
+  end
+
+  def test_rr_sets_to_xml
+    a_record = { :name => 'host.right-aws.example.com.', :type => 'A', :ttl => 600, :resource_records => ['10.0.0.1'], :action => :create }
+    expected = load_fixture('a_record.xml')
+    assert_equal expected, @r53.resource_record_sets_to_xml([a_record], '')
+
+    # Note final full stop
+    alias_target = { :hosted_zone_id => 'Z1234567890123', :dns_name => 'example-load-balancer-1111111111.us-east-1.elb.amazonaws.com.' }
+    alias_record = { :name => 'right-aws.example.com.', :type => 'A', :alias_target => alias_target, :action => :create }
+    expected = load_fixture('alias_record.xml')
+    assert_same_lines expected, @r53.resource_record_sets_to_xml([alias_record], '')
+  end
+
+  def load_fixture (name)
+    File.read(File.join(File.dirname(__FILE__), 'fixtures', name))
+  end
+
+  def assert_same_lines (expected, actual)
+    expected = expected.split "\n"
+    actual   = actual.split "\n"
+    previous = []
+    while e = expected.shift and a = actual.shift
+      assert_equal e, a, "After:\n#{previous.join("\n")}"
+      previous << e
+    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,528 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestS3 < Test::Unit::TestCase
+
+  RIGHT_OBJECT_TEXT     = 'Right test message'
+  INTERFACE = Rightscale::S3Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+  CONNECTION = Rightscale::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+
+  def setup
+    @s3     = INTERFACE
+    @bucket = 'right_s3_awesome_test_bucket_000B1_officedrop'
+    @bucket2 = 'right_s3_awesome_test_bucket_000B2_officedrop'
+    @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      = CONNECTION
+  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.right_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(:force => 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(:force => 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(:force => 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/")
+    sleep 10
+
+    assert_equal({:enabled => true, :targetbucket => @bucket2, :targetprefix => "loggylogs/"}, bucket.logging_info)
+
+    assert bucket.disable_logging
+
+      # check 'Drop' method
+    assert grantee.drop
+  end
+
+  def test_40_delete_buckets
+    Rightscale::S3::Bucket.create(@s, @bucket,  false).delete(:force => true)
+    Rightscale::S3::Bucket.create(@s, @bucket2, false).delete(:force => true)
+  end
+
+  def test_41_add_cache_control_response_parameter
+    @cache_control = 'max-age=3600'
+    perform_request( 'response-cache-control' => @cache_control ) do |response|
+       assert_equal response['Cache-Control'], @cache_control
+    end
+  end
+
+  def test_42_add_cache_control_and_content_type_and_content_disposition
+    @cache_control = 'max-age=3600'
+    @content_type = 'text/plain'
+    @content_disposition = 'attachment; filename=sample.txt'
+    perform_request(
+        'response-cache-control' => @cache_control,
+        'response-content-type' => @content_type,
+        'response-content-disposition' => @content_disposition
+    ) do |response|
+      assert_equal response['Cache-Control'], @cache_control
+      assert_equal response['Content-Type'], @content_type
+      assert_equal response['Content-Disposition'], @content_disposition
+    end
+  end
+
+  def test_43_add_expires_and_content_type_and_content_disposition
+    @expires = 'Sun, 26 Jun 2011 02:58:26 GMT'
+    @content_type = 'text/plain'
+    @content_disposition = 'attachment; filename=sample.txt'
+    perform_request(
+        'response-expires' => @expires,
+        'response-content-type' => @content_type,
+        'response-content-disposition' => @content_disposition
+    ) do |response|
+      assert_equal response['Expires'], @expires
+      assert_equal response['Content-Type'], @content_type
+      assert_equal response['Content-Disposition'], @content_disposition
+    end
+  end
+
+  def test_44_delete_multiple
+    bucket = RightAws::S3::Bucket.create(@s, @bucket, true)
+
+    key1 = Rightscale::S3::Key.create(bucket, @key1)
+    key2 = Rightscale::S3::Key.create(bucket, @key2)
+    key3 = Rightscale::S3::Key.create(bucket, @key3)
+
+    assert @s3.put(@bucket, @key1, RIGHT_OBJECT_TEXT), 'Put bucket fail'
+    assert @s3.put(@bucket, @key2, RIGHT_OBJECT_TEXT), 'Put bucket fail'
+    assert @s3.put(@bucket, @key3, RIGHT_OBJECT_TEXT), 'Put bucket fail'
+
+    key1.refresh
+    key2.refresh
+    key3.refresh
+
+    assert key1.exists?
+    assert key2.exists?
+    assert key3.exists?
+
+    result = @s3.delete_multiple(@bucket, [@key1, @key2, @key3])
+    assert result.empty?
+
+    key1.refresh
+    key2.refresh
+    key3.refresh
+
+    assert !key1.exists?
+    assert !key2.exists?
+    assert !key3.exists?
+  end
+
+  def test_45_delete_multiple_more_than_1000_objects
+    n = 1200
+    keys = (1..n).map { |i| "key-#{i}"}
+
+    keys.each do |key|
+      assert @s3.put(@bucket, key, RIGHT_OBJECT_TEXT), 'Put bucket fail'
+    end
+
+    result = @s3.delete_multiple(@bucket, keys)
+    assert result.empty?
+
+    keys_after = @s3.list_bucket(@bucket).map { |obj| obj[:key] }
+
+    keys.each do |key|
+      keys_after.include?(key)
+    end
+  end
+
+  private
+
+  def request( uri )
+    url = URI.parse( uri )
+
+    http = Net::HTTP.new(url.host, 443)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    http.request(Net::HTTP::Get.new( url.request_uri ))
+  end
+
+  def perform_request( headers, &block )
+    @s3.create_bucket( @bucket )
+    @s3.put( @bucket, @key2, RIGHT_OBJECT_TEXT )
+    response = request( @s3.get_link( @bucket, @key2, nil, {}, headers ) )
+    block.call( response )
+    @s3.force_delete_bucket(@bucket)
+  end
+
+end