poolparty 1.3.15 → 1.4.0

data/vendor/gems/right_aws/test/sdb/test_active_sdb.rb

@@ -1,299 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestSdb < Test::Unit::TestCase
-  
-  DOMAIN_NAME = 'right_sdb_awesome_test_domain'
-  
-  class Client < RightAws::ActiveSdb::Base
-    set_domain_name DOMAIN_NAME
-  end
-
-  def setup
-    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'] } ]
-    RightAws::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
-
-  #---------------------------
-  # Rightscale::SdbInterface
-  #---------------------------
-
-  def test_00_delete_domain
-    assert RightAws::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 !RightAws::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 RightAws::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'=?] intersection ['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'=?] intersection ['country'=?] union ['gender'=?]",'president', 'Russia','female']).size
-    # find all rissian presidents Bushes
-    assert_equal 0, Client.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, 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(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
-    # find any record
-    assert Client.find(:first)
-    # find any president
-    assert Client.find(:first, :conditions => ["[?=?]",'post','president'])
-    # find any rissian president
-    assert Client.find(:first, :conditions => ["['post'=?] intersection ['country'=?]",'president','Russia'])
-    # find any unexistent record
-    assert_nil Client.find(:first, :conditions => ["['post'=?] intersection ['country'=?]",'president','Rwanda'])
-  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(Rightscale::AwsError) do 
-      Client.find :all 
-    end
-  end
-    
-end

data/vendor/gems/right_aws/test/sdb/test_helper.rb

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

data/vendor/gems/right_aws/test/sdb/test_right_sdb.rb

@@ -1,247 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestSdb < Test::Unit::TestCase
-
-  def setup
-    STDOUT.sync  = true
-    @domain = 'right_sdb_awesome_test_domain'
-    @item   = 'toys'
-    @attr   = { 'Jon' => %w{beer car} }
-    # Interface instance
-    @sdb    = Rightscale::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
-
-  #---------------------------
-  # Rightscale::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 values, ['girls', 'vodka']
-    # delete an item
-    @sdb.delete_attributes @domain, @item
-    # get attributes (values must be empty)
-    values = @sdb.get_attributes(@domain, @item)[:attributes]['Volodya']
-    assert_equal values, nil
-  end  
-  
-  def test_08_query
-    # add some values for query
-    @sdb.put_attributes @domain, @item, {'Jon' => ['girls','vodka']}
-    wait SDB_DELAY, 'after adding attributes'
-    items = @sdb.query(@domain, ['[?=?]', 'Jon','vodka'])[:items]
-    assert_equal items.size, 1
-    assert_equal items.first, @item
-  end
-  
-  def test_09_signature_version_0 
-    sdb    = Rightscale::SdbInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key, :signature_version => '0') 
-    item   = 'toys' 
-    # TODO: need to change the below test.  I think Juergen's intention was to include some umlauts in the values
-    # put attributes 
-    # mhhh... Not sure how to translate this: hölzchehn klötzchen grÃŒnspan buße... Lets assume this is:
-    attributes = { 'Jurgen' => %w{kitten puppy chickabiddy piglet} } 
-    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 
-    # 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_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_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_14_nil_attrs
-    item = 'nils'
-    res = nil
-    assert_nothing_thrown do
-      @sdb.put_attributes(@domain, item, {:one=>nil, :two=>nil, :three=>'chunder'})
-    end
-    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_15_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_16_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_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 5, 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
-    # 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
-    # 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_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

data/vendor/gems/right_aws/test/sqs/test_helper.rb

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