right_aws 1.9.0 → 3.1.0

data/test/s3/test_right_s3_stubbed.rb

@@ -81,15 +81,17 @@ class TestS3Stubbed < Test::Unit::TestCase
   def test_116_move_key
     # move a key
     Rightscale::HttpConnection.push(413, 'not found') 
-    assert @s3.move(@bucket, @key1, @bucket, @key1_new_name)
-    
+    assert_raise RightAws::AwsError do
+      @s3.move(@bucket, @key1, @bucket, @key1_new_name)
+    end
   end
 
   def test_117_rename_key
     # rename a key
     Rightscale::HttpConnection.push(500, 'not found') 
-    assert @s3.rename(@bucket, @key2, @key2_new_name)
-    
+    assert_raise RightAws::AwsError do
+      @s3.rename(@bucket, @key2, @key2_new_name)
+    end
   end
 
 end

data/test/sdb/test_active_sdb.rb

@@ -1,11 +1,25 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
 class TestSdb < Test::Unit::TestCase
-  
-  DOMAIN_NAME = 'right_sdb_awesome_test_domain'
-  
+  DOMAIN_PREFIX = 'right_sdb_awesome_test'
+  CLIENT_DOMAIN = "#{DOMAIN_PREFIX}_client"
+  PERSON_DOMAIN = "#{DOMAIN_PREFIX}_person"
+
   class Client < RightAws::ActiveSdb::Base
-    set_domain_name DOMAIN_NAME
+    set_domain_name CLIENT_DOMAIN
+  end
+
+  class Person < RightAws::ActiveSdb::Base
+    set_domain_name PERSON_DOMAIN
+
+    columns do
+      name
+      email
+      score         :Integer
+      is_active     :Boolean
+      registered_at :DateTime
+      created_at    :DateTime, :default => lambda{ Time.now }
+    end
   end
 
   def setup
@@ -17,6 +31,13 @@ class TestSdb < Test::Unit::TestCase
       { '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'] } ]
+    @people = [
+      { :name => 'Yetta E. Andrews',    :email => 'nulla.facilisis@metus.com', :score => 100, :is_active => true,  :registered_at => Time.local(2000, 1, 1) },
+      { :name => 'Sybill O. Olson',     :email => 'nisi.Aenean.eget@urna.com', :score =>  87, :is_active => true,  :registered_at => Time.local(2008, 7, 6) },
+      { :name => 'Isabelle K. Flynn',   :email => 'velit@amet.com',            :score =>  98, :is_active => false, :registered_at => Time.local(2003, 5, 20) },
+      { :name => 'Juliet H. Witt',      :email => 'egestas@pretiumaliquet.ca', :score =>  72, :is_active => true,  :registered_at => Time.local(2007, 2, 28) },
+      { :name => 'Lucy N. Christensen', :email => 'lacus.v12@stu.edu',         :score =>  94, :is_active => false, :registered_at => Time.local(2005, 10, 26) }
+    ]
     RightAws::ActiveSdb.establish_connection(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
   end
 
@@ -37,24 +58,26 @@ class TestSdb < Test::Unit::TestCase
   #---------------------------
 
   def test_00_delete_domain
-    assert RightAws::ActiveSdb.delete_domain(DOMAIN_NAME)
+    assert RightAws::ActiveSdb.delete_domain(CLIENT_DOMAIN)
+    assert RightAws::ActiveSdb.delete_domain(PERSON_DOMAIN)
     wait SDB_DELAY, 'test 00: after domain deletion'
   end
   
   def test_01_create_domain
     # check that domain does not exist
-    assert !RightAws::ActiveSdb.domains.include?(DOMAIN_NAME)
+    assert !RightAws::ActiveSdb.domains.include?(CLIENT_DOMAIN)
     # create domain
     assert Client.create_domain
+    assert Person.create_domain
     wait SDB_DELAY, 'test 01: after domain creation'
     # check that we have received new domain from Amazin
-    assert RightAws::ActiveSdb.domains.include?(DOMAIN_NAME)
+    assert RightAws::ActiveSdb.domains.include?(CLIENT_DOMAIN)
   end
 
   def test_02_create_items
     # check that DB is empty
     clients = Client.find(:all)
-    assert clients.blank?
+    assert clients.right_blank?
     # put some clients there
     @clients.each do |client|
       Client.create client
@@ -107,6 +130,10 @@ class TestSdb < Test::Unit::TestCase
     assert_raise(RightAws::ActiveSdb::ActiveSdbError) do 
       Client.find(ids)
     end
+    # find one record by unknown id
+    assert_raise(RightAws::ActiveSdb::ActiveSdbError) do
+      Client.find('dummy_id')
+    end
   end
 
   def test_05_find_first
@@ -144,7 +171,7 @@ class TestSdb < Test::Unit::TestCase
     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)
@@ -163,9 +190,44 @@ class TestSdb < Test::Unit::TestCase
     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_09_save_and_put
+  def test_11_save_and_put
     putin = Client.find_by_name('Putin')
     putin.reload
     putin['hobby'] = 'ski'
@@ -194,7 +256,7 @@ class TestSdb < Test::Unit::TestCase
     assert ['dogs', 'ski'], new_putin['hobby'].sort
   end
 
-  def test_10_save_and_put_attributes
+  def test_12_save_and_put_attributes
     putin = Client.find_by_name('Putin')
     putin.reload
     # SAVE method (replace values)
@@ -220,12 +282,16 @@ class TestSdb < Test::Unit::TestCase
     assert ['english', 'german', 'russian'], new_putin['language'].sort
   end
   
-  def test_11_delete
+  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
-    putin.delete_values('language' => ['english', 'german'])
+    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')
@@ -244,12 +310,47 @@ class TestSdb < Test::Unit::TestCase
     wait SDB_DELAY, 'test 11: after delete item'
     assert_nil Client.find_by_name('Putin')
   end
-  
-  def test_12_delete_domain
+
+  def test_14_dynamic_attribute_accessors
+    bush = Client.find_by_name('Bush')
+    bush.reload
+    assert_nothing_raised {
+      assert_equal ['male'], bush.gender
+      bush.name = 'George'
+      assert_equal ['George'], bush.name
+    }
+    assert_raise(NoMethodError) { bush.flarble }
+  end
+
+  def test_15_column_emulation
+    @people.each do |person|
+      Person.create person
+    end
+    wait SDB_DELAY, 'test 15: after people creation'
+    person = Person.find_by_email 'nulla.facilisis@metus.com'
+    person.reload
+
+    assert_equal 'Yetta E. Andrews', person.name
+    assert_equal DateTime, person.registered_at.class
+    assert person['registered_at'].is_a?(DateTime)
+    assert person[:registered_at].is_a?(DateTime)
+
+    assert ! person[:created_at].nil?
+    assert_equal DateTime, person.created_at.class
+    assert person['created_at'].is_a?(DateTime)
+    assert person[:created_at].is_a?(DateTime)
+
+    assert person.is_active
+
+    assert_equal 100, person.score
+  end
+
+  def test_999_delete_domain
     assert Client.delete_domain
-    wait SDB_DELAY, 'test 12: after delete domain'
-    assert_raise(Rightscale::AwsError) do 
-      Client.find :all 
+    assert Person.delete_domain
+    wait SDB_DELAY, 'test 999: after delete domain'
+    assert_raise(Rightscale::AwsError) do
+      Client.find :all
     end
   end
     

data/test/sdb/test_batch_put_attributes.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestSdb < Test::Unit::TestCase
+
+  def setup
+    STDOUT.sync  = true
+    @domain = 'right_sdb_awesome_test_domain'
+    @attributes = {
+      'a' => { 'foo' => '123' },
+      'b' => { 'bar' => '456' }
+    }
+    # Interface instance
+    @sdb = Rightscale::SdbInterface.new
+    @sdb.delete_domain(@domain)
+    wait(SDB_DELAY, "after removing domain")
+    @sdb.create_domain(@domain)
+    wait(SDB_DELAY, "after recreating domain")
+  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
+
+  def test_batch_put_attributes
+    @sdb.batch_put_attributes(@domain, @attributes)
+    wait(SDB_DELAY, "after putting attributes")
+    a = @sdb.get_attributes(@domain, 'a')[:attributes]
+    b = @sdb.get_attributes(@domain, 'b')[:attributes]
+    assert_equal( {'foo' => ['123']}, a)
+    assert_equal( {'bar' => ['456']}, b)
+    
+    # Replace = false
+    @sdb.batch_put_attributes(@domain, { 'a' => {'foo' => ['789']}})
+    wait(SDB_DELAY, "after putting attributes") 
+    a = @sdb.get_attributes(@domain, 'a')[:attributes]
+    assert_equal ['123', '789'], a['foo'].sort
+
+    # Replace = true
+    @sdb.batch_put_attributes(@domain, {'b' => {'bar' => ['789']}}, true)
+    wait(SDB_DELAY, "after putting attributes") 
+    b = @sdb.get_attributes(@domain, 'b')[:attributes]
+    assert_equal ['789'], b['bar'].sort
+
+  end
+end

data/test/sdb/test_right_sdb.rb

@@ -11,7 +11,7 @@ class TestSdb < Test::Unit::TestCase
     @sdb    = Rightscale::SdbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
   end
 
-  SDB_DELAY = 2
+  SDB_DELAY = 7
   
   def wait(delay, msg='')
     print "waiting #{delay} seconds #{msg}"
@@ -51,7 +51,7 @@ class TestSdb < Test::Unit::TestCase
   
   def test_03_get_attributes
     # get attributes
-    values = @sdb.get_attributes(@domain, @item)[:attributes]['Jon'].to_a.sort
+    values = Array(@sdb.get_attributes(@domain, @item)[:attributes]['Jon']).sort
     # compare to original list
     assert_equal values, @attr['Jon'].sort
   end
@@ -62,7 +62,7 @@ class TestSdb < Test::Unit::TestCase
     @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
+    values = Array(@sdb.get_attributes(@domain, @item)[:attributes]['Jon']).sort
     assert_equal values, (@attr['Jon'] << new_value).sort
   end
   
@@ -80,7 +80,7 @@ class TestSdb < Test::Unit::TestCase
     @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
+    values = Array(@sdb.get_attributes(@domain, @item)[:attributes]['Jon']).sort
     assert_equal values, ['girls', 'pub', 'vodka']
     # delete a single value 'girls' from attribute 'Jon'
     @sdb.delete_attributes @domain, @item, 'Jon' => ['girls']
@@ -100,10 +100,11 @@ class TestSdb < Test::Unit::TestCase
     @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
+    values = Array(@sdb.get_attributes(@domain, @item)[:attributes]['Volodya']).sort
     assert_equal values, ['girls', 'vodka']
     # delete an item
     @sdb.delete_attributes @domain, @item
+    wait SDB_DELAY, 'after deleting attributes'
     # get attributes (values must be empty)
     values = @sdb.get_attributes(@domain, @item)[:attributes]['Volodya']
     assert_equal values, nil
@@ -128,33 +129,52 @@ class TestSdb < Test::Unit::TestCase
     assert sdb.put_attributes(@domain, item, attributes) 
     wait SDB_DELAY, 'after putting attributes' 
     # get attributes 
-    values = sdb.get_attributes(@domain, item)[:attributes]['Jurgen'].to_a.sort 
+    values = Array(sdb.get_attributes(@domain, item)[:attributes]['Jurgen']).sort
     # compare to original list 
     assert_equal values, attributes['Jurgen'].sort 
     # check that the request has correct signature version
     assert sdb.last_request.path.include?('SignatureVersion=0')
   end 
-  
-  def test_10_array_of_attrs
+
+  def test_10_signature_version_1
+    sdb = Rightscale::SdbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :signature_version => '1')
+    domains = nil
+    assert_nothing_thrown "Failed to use signature V1" do
+      domains = sdb.list_domains
+    end
+    assert domains
+  end
+
+  def test_11_signature_version_1
+    sdb = Rightscale::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_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_11_zero_len_attrs
+  def test_13_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_12_nil_attrs
+  def test_14_nil_attrs
     item = 'nils'
     res = nil
     assert_nothing_thrown do
       @sdb.put_attributes(@domain, item, {:one=>nil, :two=>nil, :three=>'chunder'})
     end
+    wait SDB_DELAY, 'after putting attributes'
     assert_nothing_thrown do
       res = @sdb.get_attributes(@domain, item)
     end
@@ -163,18 +183,19 @@ class TestSdb < Test::Unit::TestCase
     assert_not_nil(res[:attributes]['three'][0])
   end
   
-  def test_13_url_escape
+  def test_15_url_escape
     item = 'urlescapes'
     content = {:a=>"one & two & three",
                :b=>"one ? two / three"}
     @sdb.put_attributes(@domain, item, content)
+    wait SDB_DELAY, 'after putting attributes'
 
     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_14_put_attrs_by_post
+  def test_16_put_attrs_by_post
     item = 'reqgirth'
     i = 0
     sa = ""
@@ -183,16 +204,50 @@ class TestSdb < Test::Unit::TestCase
       i += 1
     end
     @sdb.put_attributes(@domain, item, {:a => sa, :b => sa, :c => sa, :d => sa, :e => sa})
+    wait SDB_DELAY, 'after putting attributes'
   end
-  
+
+  def test_20_query_with_atributes
+    response = @sdb.query_with_attributes(@domain)
+    # convers response to a hash representation
+    items = {};
+    response[:items].each{ |item| items.merge!(item) }
+    # check we have receied all 5 items each full of attributes
+    assert_equal 6, items.keys.size
+    assert items['toys'].size > 0
+    assert items['nils'].size > 0
+    assert items['urlescapes'].size > 0
+    assert items['multiples'].size > 0
+    assert items['reqgirth'].size > 0
+    assert items['zeroes'].size > 0
+    # fetch only Jon's attributes from all items
+    response = @sdb.query_with_attributes(@domain,['Jon'])
+    items = {};
+    response[:items].each{ |item| items.merge!(item) }
+    # check we have receied all 5 items
+    # check we have receied all 5 items, but only 'toys' has attributes
+    puts items.inspect
+    assert_equal 2, items['toys']['Jon'].size
+    assert_equal 0, items['nils'].size
+    assert_equal 0, items['urlescapes'].size
+    assert_equal 0, items['multiples'].size
+    assert_equal 0, items['reqgirth'].size
+    assert_equal 0, items['zeroes'].size
+    # kust Jurgen's attriburs
+    response = @sdb.query_with_attributes(@domain,['Jurgen'], "['Jurgen'='piglet']")
+    items = {};
+    response[:items].each{ |item| items.merge!(item) }
+    # check we have receied an only item
+    assert_equal 1, items.keys.size
+    assert_equal ["chickabiddy", "kitten", "piglet", "puppy"], items['toys']['Jurgen'].sort
+  end
+
   # Keep this test last, because it deletes the domain...
-  def test_20_delete_domain
+  def test_21_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