hackerdude-aws 2.3.25

data/test/s3/test_s3_stubbed.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestS3Stubbed < Test::Unit::TestCase
+
+  RIGHT_OBJECT_TEXT     = 'Right test message'
+  
+  def setup
+      TestCredentials.get_credentials
+    @s3     = Aws::S3Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+    @bucket = 'right_s3_awesome_test_bucket'
+    @key1   = 'test/woohoo1'
+    @key2   = 'test1/key/woohoo2'
+    @s      = Aws::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+    Rightscale::HttpConnection.reset
+  end
+
+  # Non-remote tests: these use the stub version of Rightscale::HTTPConnection
+  def test_101_create_bucket
+    Rightscale::HttpConnection.push(409, 'The named bucket you tried to create already exists')
+    Rightscale::HttpConnection.push(500, 'We encountered an internal error.  Please try again.')
+    Rightscale::HttpConnection.push(500, 'We encountered an internal error.  Please try again.')
+    assert_raise Aws::AwsError do
+      @s3.create_bucket(@bucket)
+    end
+  end
+
+  def test_102_list_all_my_buckets_failure
+    Rightscale::HttpConnection.push(401, 'Unauthorized') 
+    assert_raise Aws::AwsError do
+      @s3.list_all_my_buckets
+    end
+  end
+
+  def test_103_list_empty_bucket
+    Rightscale::HttpConnection.push(403, 'Access Denied') 
+    assert_raise Aws::AwsError do
+      @s3.list_bucket(@bucket)
+    end
+  end
+  
+  def test_104_put
+    Rightscale::HttpConnection.push(400, 'Your proposed upload exceeds the maximum allowed object size.') 
+    Rightscale::HttpConnection.push(400, 'The Content-MD5 you specified was an invalid.') 
+    Rightscale::HttpConnection.push(409, 'Please try again') 
+    assert_raise Aws::AwsError do
+      assert @s3.put(@bucket, @key1, RIGHT_OBJECT_TEXT, 'x-amz-meta-family'=>'Woohoo1!'), 'Put bucket fail'
+    end
+    assert_raise Aws::AwsError do
+      assert @s3.put(@bucket, @key2, RIGHT_OBJECT_TEXT, 'x-amz-meta-family'=>'Woohoo2!'), 'Put bucket fail'
+    end
+  end
+  
+  def test_105_get_and_get_object
+    Rightscale::HttpConnection.push(404, 'not found') 
+    assert_raise(Rightscale::AwsError) { @s3.get(@bucket, 'undefined/key') }
+  end
+  
+  def test_106_head
+    Rightscale::HttpConnection.push(404, 'Good Luck!') 
+    assert_raise Aws::AwsError do
+      @s3.head(@bucket,@key1)
+    end
+  end
+
+
+  def test_109_delete_bucket
+    Rightscale::HttpConnection.push(403, 'Good Luck!') 
+    assert_raise(Rightscale::AwsError) { @s3.delete_bucket(@bucket) }
+  end
+  
+  def test_115_copy_key
+    
+    Rightscale::HttpConnection.push(500, 'not found') 
+    #--- test COPY
+    # copy a key
+    assert_raise Aws::AwsError do
+      @s3.copy(@bucket, @key1, @bucket, @key1_copy)
+    end
+    
+  end
+
+  def test_116_move_key
+    # move a key
+    Rightscale::HttpConnection.push(413, 'not found') 
+    assert @s3.move(@bucket, @key1, @bucket, @key1_new_name)
+    
+  end
+
+  def test_117_rename_key
+    # rename a key
+    Rightscale::HttpConnection.push(500, 'not found') 
+    assert @s3.rename(@bucket, @key2, @key2_new_name)
+    
+  end
+
+end

data/test/sdb/test_active_sdb.rb

@@ -0,0 +1,338 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestSdb < Test::Unit::TestCase
+  
+  DOMAIN_NAME = 'right_sdb_awesome_test_domain'
+  DASH_DOMAIN_NAME = 'right_sdb-awesome_test_domain'
+  
+  class Client < Aws::ActiveSdb::Base
+    set_domain_name DOMAIN_NAME
+  end
+  class DashClient < RightAws::ActiveSdb::Base
+    set_domain_name DASH_DOMAIN_NAME
+  end
+
+  def setup
+      TestCredentials.get_credentials
+    STDOUT.sync  = true
+    @clients = [ 
+      { 'name' => 'Bush',     'country' => 'USA',    'gender' => 'male',   'expiration' => '2009', 'post' => 'president' },
+      { 'name' => 'Putin',    'country' => 'Russia', 'gender' => 'male',   'expiration' => '2008', 'post' => 'president' },
+      { 'name' => 'Medvedev', 'country' => 'Russia', 'gender' => 'male',   'expiration' => '2012', 'post' => 'president' },
+      { 'name' => 'Mary',     'country' => 'USA',    'gender' => 'female', 'hobby' => ['patchwork', 'bundle jumping'] },
+      { 'name' => 'Sandy',    'country' => 'Russia', 'gender' => 'female', 'hobby' => ['flowers', 'cats', 'cooking'] },
+      { 'name' => 'Mary',     'country' => 'Russia', 'gender' => 'female', 'hobby' => ['flowers', 'cats', 'cooking'] } ]
+    Aws::ActiveSdb.establish_connection(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+  end
+
+  SDB_DELAY = 3
+  
+  def wait(delay, msg='')
+    print "     waiting #{delay} seconds: #{msg}"
+    while delay>0 do
+      delay -= 1
+      print '.'
+      sleep 1
+    end
+    puts
+  end
+
+  #---------------------------
+  # Aws::SdbInterface
+  #---------------------------
+
+  def test_00_delete_domain
+    assert Aws::ActiveSdb.delete_domain(DOMAIN_NAME)
+    wait SDB_DELAY, 'test 00: after domain deletion'
+  end
+  
+  def test_01_create_domain
+    # check that domain does not exist
+    assert !Aws::ActiveSdb.domains.include?(DOMAIN_NAME)
+    # create domain
+    assert Client.create_domain
+    wait SDB_DELAY, 'test 01: after domain creation'
+    # check that we have received new domain from Amazin
+    assert Aws::ActiveSdb.domains.include?(DOMAIN_NAME)
+  end
+
+  def test_02_create_items
+    # check that DB is empty
+    clients = Client.find(:all)
+    assert clients.blank?
+    # put some clients there
+    @clients.each do |client|
+      Client.create client
+    end
+    wait SDB_DELAY, 'test 02: after clients creation'
+    # check that DB has all the clients we just putted
+    clients = Client.find(:all)
+    assert_equal @clients.size, clients.size
+  end
+  
+  def test_03_create_and_save_new_item
+    # get the db
+    old_clients = Client.find(:all)
+    # create new client
+    new_client = Client.new('country' => 'unknown', 'dummy' => 'yes')
+    wait SDB_DELAY, 'test 03: after in-memory client creation'
+    # get the db and ensure we created the client in-memory only
+    assert_equal old_clients.size, Client.find(:all).size
+    # put the client to DB
+    new_client.save
+    wait SDB_DELAY, 'test 03: after in-memory client saving'
+    # get all db again and compare to original list
+    assert_equal old_clients.size+1, Client.find(:all).size
+  end
+
+  def test_04_find_all
+    # retrieve all the DB, make sure all are in place
+    clients = Client.find(:all)
+    ids = clients.map{|client| client.id }[0..1]
+    assert_equal @clients.size + 1, clients.size
+    # retrieve all presidents (must find: Bush, Putin, Medvedev)
+    assert_equal 3, Client.find(:all, :conditions => ["post=?",'president']).size
+    # retrieve all russian presidents (must find: Putin, Medvedev)
+    assert_equal 2, Client.find(:all, :conditions => ["post=? and country=?",'president', 'Russia']).size
+    # retrieve all russian presidents and all women (must find: Putin, Medvedev, 2 Maries and Sandy)
+    assert_equal 5, Client.find(:all, :conditions => ["post=? and country=? or gender=?",'president', 'Russia','female']).size
+    # find all rissian presidents Bushes
+    assert_equal 0, Client.find(:all, :conditions => ["post=? and country=? and name=?",'president', 'Russia','Bush']).size
+    # --- find by ids
+    # must find 1 rec (by rec id) and return it
+    assert_equal ids.first, Client.find(ids.first).id
+    # must find 1 rec (by one item array) and return an array
+    assert_equal ids.first, Client.find([ids.first]).first.id
+    # must find 2 recs (by a list of comma separated ids) and return an array
+    assert_equal ids.size, Client.find(*ids).size
+    # must find 2 recs (by an array of ids) and return an array
+    assert_equal ids.size, Client.find(ids).size
+    ids << 'dummy_id'
+    # must raise an error when getting unexistent record
+    assert_raise(Aws::ActiveSdb::ActiveSdbError) do
+      Client.find(ids)
+    end
+    # find one record by unknown id
+    assert_raise(Aws::ActiveSdb::ActiveSdbError) do
+      Client.find('dummy_id')
+    end
+  end
+
+  def test_04b_find_all_dashed
+    # retrieve all the DB, make sure all are in place
+    clients = DashClient.find(:all)
+    ids = clients.map{|client| client.id }[0..1]
+    assert_equal @clients.size + 1, clients.size
+    # retrieve all presidents (must find: Bush, Putin, Medvedev)
+    assert_equal 3, DashedClient.find(:all, :conditions => ["[?=?]",'post','president']).size
+    # retrieve all russian presidents (must find: Putin, Medvedev)
+    assert_equal 2, DashedClient.find(:all, :conditions => ["['post'=?] intersection ['country'=?]",'president', 'Russia']).size
+    # retrieve all russian presidents and all women (must find: Putin, Medvedev, 2 Maries and Sandy)
+    assert_equal 5, DashedClient.find(:all, :conditions => ["['post'=?] intersection ['country'=?] union ['gender'=?]",'president', 'Russia','female']).size
+    # find all rissian presidents Bushes
+    assert_equal 0, DashedClient.find(:all, :conditions => ["['post'=?] intersection ['country'=?] intersection ['name'=?]",'president', 'Russia','Bush']).size
+    # --- find by ids
+    # must find 1 rec (by rec id) and return it
+    assert_equal ids.first, DashedClient.find(ids.first).id
+    # must find 1 rec (by one item array) and return an array
+    assert_equal ids.first, DashedClient.find([ids.first]).first.id
+    # must find 2 recs (by a list of comma separated ids) and return an array
+    assert_equal ids.size, DashedClient.find(*ids).size
+    # must find 2 recs (by an array of ids) and return an array
+    assert_equal ids.size, DashedClient.find(ids).size
+    ids << 'dummy_id'
+    # must raise an error when getting unexistent record
+    assert_raise(RightAws::ActiveSdb::ActiveSdbError) do 
+      DashedClient.find(ids)
+    end
+    # find one record by unknown id
+    assert_raise(RightAws::ActiveSdb::ActiveSdbError) do
+      DashedClient.find('dummy_id')
+    end
+  end
+
+  def test_05_find_first
+    # find any record
+    assert Client.find(:first)
+    # find any president
+    assert Client.find(:first, :conditions => ["post=? and country=?",'president','Russia'])
+    # find any rissian president
+    assert_nil Client.find(:first, :conditions => ["post=? and country=?",'president','Rwanda'])
+    # find any unexistent record
+    assert Client.find(:first, :conditions => ["?=?",'post','president'])
+  end
+
+  def test_06_find_all_by_helpers
+    # find all Bushes
+    assert_equal 1, Client.find_all_by_name('Bush').size
+    # find all russian presidents
+    assert_equal 2, Client.find_all_by_post_and_country('president','Russia').size
+    # find all women in USA that love flowers
+    assert_equal 2, Client.find_all_by_gender_and_country_and_hobby('female','Russia','flowers').size
+    # order and auto_load:
+    clients = Client.find_all_by_post('president', :order => 'name', :auto_load => true)
+    assert_equal [['Bush'], ['Medvedev'], ['Putin']], clients.map{|c| c['name']}
+    clients = Client.find_all_by_post('president', :order => 'name desc', :auto_load => true)
+    assert_equal [['Putin'], ['Medvedev'], ['Bush']], clients.map{|c| c['name']}
+  end
+  
+  def test_07_find_by_helpers
+    # find mr Bush
+    assert Client.find_by_name('Bush')
+    # find any russian president
+    assert Client.find_by_post_and_country('president','Russia')
+    # find Mary in Russia that loves flowers
+    # order and auto_load:
+    assert_equal ['Bush'],  Client.find_by_post('president', :order => 'name',      :auto_load => true)['name']
+    assert_equal ['Putin'], Client.find_by_post('president', :order => 'name desc', :auto_load => true)['name']
+  end
+
+  def test_08_reload
+    putin = Client.find_by_name('Putin')
+    # attributes must be empty until reload (except 'id' field)
+    assert_nil putin['name']
+    assert_nil putin['country']
+    assert_nil putin['gender']
+    assert_nil putin['expiration']
+    assert_nil putin['post']
+    # reloaded attributes must have 5 items + id
+    putin.reload
+    assert_equal 6, putin.attributes.size
+    # check all attributes
+    assert_equal ['Putin'],     putin['name']
+    assert_equal ['Russia'],    putin['country']
+    assert_equal ['male'],      putin['gender']
+    assert_equal ['2008'],      putin['expiration']
+    assert_equal ['president'], putin['post']
+  end
+
+  def test_09_select
+    # select all records
+    assert_equal 7, Client.select(:all).size
+    # LIMIT
+    # 1 record
+    assert Client.select(:first).is_a?(Client)
+    # select 2 recs
+    assert_equal 2, Client.select(:all, :limit => 2).size
+    # ORDER
+    # select all recs ordered by 'expration' (must find only recs where 'expration' attribute presents)
+    result = Client.select(:all, :order => 'expiration')
+    assert_equal 3, result.size
+    assert_equal ['2008', '2009', '2012'], result.map{ |c| c['expiration'] }.flatten
+    # desc order
+    result = Client.select(:all, :order => 'expiration desc')
+    assert_equal ['2012', '2009', '2008'], result.map{ |c| c['expiration'] }.flatten
+    # CONDITIONS
+    result = Client.select(:all, :conditions => ["expiration >= ?", 2009], :order => 'name')
+    assert_equal ['Bush', 'Medvedev'], result.map{ |c| c['name'] }.flatten
+    result = Client.select(:all, :conditions => "hobby='flowers' AND gender='female'", :order => 'name')
+    assert_equal ['Mary', 'Sandy'], result.map{ |c| c['name'] }.flatten
+    # SELECT
+    result = Client.select(:all, :select => 'hobby', :conditions => "gender IS NOT NULL", :order => 'name')
+    hobbies = result.map{|c| c['hobby']}
+    # must return all recs
+    assert_equal 6, result.size
+    # but anly 3 of them have this field set
+    assert_equal 3, hobbies.compact.size
+  end
+
+  def test_10_select_by
+    assert_equal 2, Client.select_all_by_hobby('flowers').size
+    assert_equal 2, Client.select_all_by_hobby_and_country('flowers', 'Russia').size
+    assert_equal ['Putin'], Client.select_by_post_and_expiration('president','2008')['name']
+  end
+  
+  def test_11_save_and_put
+    putin = Client.find_by_name('Putin')
+    putin.reload
+    putin['hobby'] = 'ski'
+    # SAVE method (replace values)
+    putin.save
+    wait SDB_DELAY, 'test 09: after saving'
+    # check that DB was updated with 'ski'
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['ski'], new_putin['hobby']
+    # replace hobby
+    putin['hobby'] = 'dogs'
+    putin.save
+    wait SDB_DELAY, 'test 09: after saving'
+    # check that 'ski' in DB was replaced by 'dogs'
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['dogs'], new_putin['hobby']
+    # PUT method (add values)
+    putin['hobby'] = 'ski'
+    putin.put
+    wait SDB_DELAY, 'test 09: after putting'
+    # check that 'ski' was added to 'dogs'
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['dogs', 'ski'], new_putin['hobby'].sort
+  end
+
+  def test_12_save_and_put_attributes
+    putin = Client.find_by_name('Putin')
+    putin.reload
+    # SAVE method (replace values)
+    putin.save_attributes('language' => 'russian')
+    wait SDB_DELAY, 'test 10: after save_attributes'
+    # check that DB was updated with 'ski'
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['russian'], new_putin['language']
+    # replace 'russian' by 'german'
+    putin.save_attributes('language' => 'german')
+    wait SDB_DELAY, 'test 10: after save_attributes'
+    # check that 'russian' in DB was replaced by 'german'
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['german'], new_putin['language']
+    # PUT method (add values)
+    putin.put_attributes('language' => ['russian', 'english'])
+    wait SDB_DELAY, 'test 10: after put_attributes'
+    # now Putin must know all the languages
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['english', 'german', 'russian'], new_putin['language'].sort
+  end
+  
+  def test_13_delete
+    putin = Client.find_by_name('Putin')
+    putin.reload
+    # --- delete_values
+    # remove an unknown attribute
+    # should return an empty hash
+    assert_equal( {}, putin.delete_values('undefined_attribute' => 'ohoho'))
+    # remove 2 languages
+    lang_hash = {'language' => ['english', 'german']}
+    assert_equal lang_hash, putin.delete_values(lang_hash)
+    wait SDB_DELAY, 'test 11: after put_attributes'
+    # now Putin must know only russian lang
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert ['russian'], new_putin['language'].sort
+    # --- delete_attributes
+    putin.delete_attributes('language', 'hobby')
+    wait SDB_DELAY, 'test 11: after delete_attributes'
+    # trash hoddy and langs
+    new_putin = Client.find_by_name('Putin')
+    new_putin.reload
+    assert_nil new_putin['language']
+    assert_nil new_putin['hobby']
+    # --- delete item
+    putin.delete
+    wait SDB_DELAY, 'test 11: after delete item'
+    assert_nil Client.find_by_name('Putin')
+  end
+  
+  def test_14_delete_domain
+    assert Client.delete_domain
+    wait SDB_DELAY, 'test 12: after delete domain'
+    assert_raise(Aws::AwsError) do
+      Client.find :all 
+    end
+  end
+    
+end

data/test/sdb/test_helper.rb

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

data/test/sdb/test_sdb.rb

@@ -0,0 +1,207 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestSdb < Test::Unit::TestCase
+
+    def setup
+        TestCredentials.get_credentials
+        STDOUT.sync = true
+        @domain = 'right_sdb_awesome_test_domain'
+        @item = 'toys'
+        @attr = { 'Jon' => %w{beer car} }
+        # Interface instance
+        @sdb = Aws::SdbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
+    end
+
+    SDB_DELAY = 2
+
+    def wait(delay, msg='')
+        print "waiting #{delay} seconds #{msg}"
+        while delay>0 do
+            delay -= 1
+            print '.'
+            sleep 1
+        end
+        puts
+    end
+
+    #---------------------------
+    # Aws::SdbInterface
+    #---------------------------
+
+    def test_00_delete_domain
+        # delete the domain to reset all the things
+        assert @sdb.delete_domain(@domain), 'delete_domain fail'
+        wait SDB_DELAY, 'after domain deletion'
+    end
+
+    def test_01_create_domain
+        # check that domain does not exist
+        assert !@sdb.list_domains[:domains].include?(@domain)
+        # create domain
+        assert @sdb.create_domain(@domain), 'create_domain fail'
+        wait SDB_DELAY, 'after domain creation'
+        # check that we have received new domain from Amazin
+        assert @sdb.list_domains[:domains].include?(@domain)
+    end
+
+    def test_02_put_attributes
+        # put attributes
+        assert @sdb.put_attributes(@domain, @item, @attr)
+        wait SDB_DELAY, 'after putting attributes'
+    end
+
+    def test_03_get_attributes
+        # get attributes
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon'].to_a.sort
+        # compare to original list
+        assert_equal values, @attr['Jon'].sort
+    end
+
+    def test_04_add_attributes
+        # add new attribute
+        new_value = 'girls'
+        @sdb.put_attributes @domain, @item, {'Jon' => new_value}
+        wait SDB_DELAY, 'after putting attributes'
+        # get attributes ('girls' must be added to already existent attributes)
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon'].to_a.sort
+        assert_equal values, (@attr['Jon'] << new_value).sort
+    end
+
+    def test_05_replace_attributes
+        # replace attributes
+        @sdb.put_attributes @domain, @item, {'Jon' => 'pub'}, :replace
+        wait SDB_DELAY, 'after replacing attributes'
+        # get attributes (all must be removed except of 'pub')
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon']
+        assert_equal values, ['pub']
+    end
+
+    def test_06_delete_attribute
+        # add value 'girls' and 'vodka' to 'Jon'
+        @sdb.put_attributes @domain, @item, {'Jon' => ['girls', 'vodka']}
+        wait SDB_DELAY, 'after adding attributes'
+        # get attributes ('girls' and 'vodka' must be added 'pub')
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon'].to_a.sort
+        assert_equal values, ['girls', 'pub', 'vodka']
+        # delete a single value 'girls' from attribute 'Jon'
+        @sdb.delete_attributes @domain, @item, 'Jon' => ['girls']
+        wait SDB_DELAY, 'after the deletion of attribute'
+        # get attributes ('girls' must be removed)
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon']
+        assert_equal values, ['pub', 'vodka']
+        # delete all values from attribute 'Jon'
+        @sdb.delete_attributes @domain, @item, ['Jon']
+        wait SDB_DELAY, 'after the deletion of attributes'
+        # get attributes (values must be empty)
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon']
+        assert_equal values, nil
+    end
+
+    def test_07_delete_item
+        @sdb.put_attributes @domain, @item, {'Volodya' => ['girls', 'vodka']}
+        wait SDB_DELAY, 'after adding attributes'
+        # get attributes ('girls' and 'vodka' must be there)
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Volodya'].to_a.sort
+        assert_equal ['girls', 'vodka'], values
+        # delete an item
+        @sdb.delete_attributes @domain, @item
+        sleep 1
+        # get attributes (values must be empty)
+        values = @sdb.get_attributes(@domain, @item)[:attributes]['Volodya']
+        assert_nil values
+    end
+
+    def test_11_signature_version_2
+        sdb = Aws::SdbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :signature_version => '2')
+        domains = nil
+        assert_nothing_thrown "Failed to use signature V2" do
+            domains = sdb.list_domains
+        end
+        assert domains
+    end
+
+    def test_12_unicode
+
+        # This was creating a bad signature
+        s = ''
+        File.open("unicode.txt", "r") { |f|
+            s = f.read
+        }
+#        s = s.force_encoding("UTF-8")
+        puts 's=' + s.inspect
+        puts "encoding? " + s.encoding.name
+#        s = s.encode("ASCII")
+        # todo: I'm thinking just iterate through characters and swap out ones that aren't in ascii range.
+        @sdb.put_attributes @domain, @item, {"badname"=>[s]}
+        sleep 1
+        value = @sdb.get_attributes(@domain, @item)[:attributes]['badname'][0]
+        puts 'value=' + value.inspect
+#        assert value == s # NOT WORKING, not even sure this is a valid test though
+
+    end
+
+    def test_15_array_of_attrs
+        item = 'multiples'
+        assert_nothing_thrown "Failed to put multiple attrs" do
+            @sdb.put_attributes(@domain, item, {:one=>1, :two=>2, :three=>3})
+        end
+    end
+
+    def test_16_zero_len_attrs
+        item = 'zeroes'
+        assert_nothing_thrown "Failed to put zero-length attributes" do
+            @sdb.put_attributes(@domain, item, {:one=>"", :two=>"", :three=>""})
+        end
+    end
+
+    def test_17_nil_attrs
+        item = 'nils'
+        res = nil
+        assert_nothing_thrown do
+            @sdb.put_attributes(@domain, item, {:one=>nil, :two=>nil, :three=>'chunder'})
+        end
+        sleep 1
+        assert_nothing_thrown do
+            res = @sdb.get_attributes(@domain, item)
+        end
+        assert_nil(res[:attributes]['one'][0])
+        assert_nil(res[:attributes]['two'][0])
+        assert_not_nil(res[:attributes]['three'][0])
+    end
+
+    def test_18_url_escape
+        item = 'urlescapes'
+        content = {:a=>"one & two & three",
+                   :b=>"one ? two / three"}
+        @sdb.put_attributes(@domain, item, content)
+
+        res = @sdb.get_attributes(@domain, item)
+        assert_equal(content[:a], res[:attributes]['a'][0])
+        assert_equal(content[:b], res[:attributes]['b'][0])
+    end
+
+    def test_19_put_attrs_by_post
+        item = 'reqgirth'
+        i = 0
+        sa = ""
+        while (i < 64) do
+            sa += "aaaaaaaa"
+            i += 1
+        end
+        @sdb.put_attributes(@domain, item, {:a => sa, :b => sa, :c => sa, :d => sa, :e => sa})
+    end
+
+    def test_21_query_with_atributes
+        # not applicable anymore
+    end
+
+    # Keep this test last, because it deletes the domain...
+    def test_40_delete_domain
+        assert @sdb.delete_domain(@domain), 'delete_domain fail'
+        wait SDB_DELAY, 'after domain deletion'
+        # check that domain does not exist
+        assert !@sdb.list_domains[:domains].include?(@domain)
+    end
+
+end