right_aws 1.10.0 → 2.0.0

data/lib/sqs/right_sqs_interface.rb

@@ -56,7 +56,7 @@ module RightAws
       #    {:server       => 'queue.amazonaws.com' # Amazon service host: 'queue.amazonaws.com'(default)
       #     :port         => 443                   # Amazon service port: 80 or 443(default)
       #     :multi_thread => true|false            # Multi-threaded (connection per each thread): true or false(default)
-      #     :signature_version => '0'              # The signature version : '0' or '1'(default)
+      #     :signature_version => '0'              # The signature version : '0', '1' or '2'(default)
       #     :logger       => Logger Object}        # Logger instance: logs to STDOUT if omitted }
       #
     def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
@@ -128,9 +128,7 @@ module RightAws
       # Sends request to Amazon and parses the response
       # Raises AwsError if any banana happened
     def request_info(request, parser) # :nodoc:
-      thread = @params[:multi_thread] ? Thread.current : Thread.main
-      thread[:sqs_connection] ||= Rightscale::HttpConnection.new(:exception => AwsError, :logger => @logger)
-      request_info_impl(thread[:sqs_connection], @@bench, request, parser)
+      request_info_impl(:sqs_connection, @@bench, request, parser)
     end
 
 

data/test/acf/test_right_acf.rb

@@ -9,7 +9,7 @@ class TestAcf < Test::Unit::TestCase
   def setup
     @acf= Rightscale::AcfInterface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
     @s3 = Rightscale::S3.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
-    @bucket_name   = "right-acf-awesome-test-bucket-0001"
+    @bucket_name   = "right-acf-awesome-test-bucket-xxx1"
     @bucket_domain = "#{@bucket_name}.s3.amazonaws.com"
   end
 
@@ -27,13 +27,18 @@ class TestAcf < Test::Unit::TestCase
       @acf.create_distribution("right-cloudfront-awesome-test-bucket-not-exist", "Mustn't to be born", true)
     end
     # a bucket is not a domain naming complied guy
-    bucket_name = 'right_cloudfront_awesome_test_bucket_BAD'
+    bucket_name = 'right_cloudfront_awesome_test_bucket_BAD_XXX'
     @s3.bucket(bucket_name, :create)
     assert_raise(Rightscale::AwsError) do
       @acf.create_distribution(bucket_name, "Mustn't to be born", true)
     end
   end
 
+  def test_02_x_delete_bad_bucket
+    bucket_name = 'right_cloudfront_awesome_test_bucket_BAD_XXX'
+    @s3.bucket(bucket_name, false).delete
+  end
+
   def test_03_create
     comment = 'WooHoo!!!'
     # create a test bucket
@@ -69,8 +74,8 @@ class TestAcf < Test::Unit::TestCase
     end
     # change a config
     config[:enabled] = false
-    config[:cnames] << 'x1.myawesomesite.com'
-    config[:cnames] << 'x2.myawesomesite.com'
+    config[:cnames] << 'xxx1.myawesomesite.com'
+    config[:cnames] << 'xxx2.myawesomesite.com'
     # set config
     set_config_result = nil
     assert_nothing_raised do
@@ -83,7 +88,7 @@ class TestAcf < Test::Unit::TestCase
       new_config = @acf.get_distribution_config(old[:aws_id])
     end
     assert           !new_config[:enabled]
-    assert_equal     new_config[:cnames].sort, ['x1.myawesomesite.com', 'x2.myawesomesite.com']
+    assert_equal     new_config[:cnames].sort, ['xxx1.myawesomesite.com', 'xxx2.myawesomesite.com']
     assert_not_equal config[:e_tag], new_config[:e_tag]
 
     # try to update the old config again (must fail because ETAG has changed)
@@ -92,19 +97,6 @@ class TestAcf < Test::Unit::TestCase
     end
   end
 
-  def test_07_caching
-    # enable caching
-    @acf.params[:cache] = true
-    # list distributions
-    @acf.list_distributions
-    # list the distributions again - cache should hit
-    assert_raise(Rightscale::AwsNoChange) do
-      @acf.list_distributions
-    end
-    # disable caching
-    @acf.params[:cache] = true
-  end
-
   def test_08_delete_distribution
     # we need ETAG so use get_distribution
     distribution = @acf.get_distribution(get_test_distribution[:aws_id])

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

@@ -6,8 +6,8 @@ class TestS3 < Test::Unit::TestCase
   
   def setup
     @s3     = Rightscale::S3Interface.new(TestCredentials.aws_access_key_id, TestCredentials.aws_secret_access_key)
-    @bucket = 'right_s3_awesome_test_bucket_000A1'
-    @bucket2 = 'right_s3_awesome_test_bucket_000A2'
+    @bucket = 'right_s3_awesome_test_bucket_000B1'
+    @bucket2 = 'right_s3_awesome_test_bucket_000B2'
     @key1   = 'test/woohoo1/'
     @key2   = 'test1/key/woohoo2'
     @key3   = 'test2/A%B@C_D&E?F+G=H"I'
@@ -403,17 +403,19 @@ class TestS3 < Test::Unit::TestCase
     assert grantee.grant(['READ_ACP', 'WRITE'])
     
     assert bucket.enable_logging(:targetbucket => targetbucket, :targetprefix => "loggylogs/")
+    sleep 10
     
-    assert_equal(bucket.logging_info, {:enabled => true, :targetbucket => @bucket2, :targetprefix => "loggylogs/"})
+    assert_equal({:enabled => true, :targetbucket => @bucket2, :targetprefix => "loggylogs/"}, bucket.logging_info)
     
     assert bucket.disable_logging
     
       # check 'Drop' method
-    assert grantee.drop
-    
-      # Delete bucket
-    bucket.delete(true)
-    targetbucket.delete(true)
+    assert grantee.drop    
+  end
+
+  def test_40_delete_buckets
+    Rightscale::S3::Bucket.create(@s, @bucket,  false).delete(true)
+    Rightscale::S3::Bucket.create(@s, @bucket2, false).delete(true)
   end
 
 end

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,18 +58,20 @@ 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
@@ -287,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_14_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_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,7 +129,7 @@ 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
@@ -173,6 +174,7 @@ class TestSdb < Test::Unit::TestCase
     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
@@ -186,6 +188,7 @@ class TestSdb < Test::Unit::TestCase
     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])
@@ -201,6 +204,7 @@ 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
@@ -209,12 +213,13 @@ class TestSdb < Test::Unit::TestCase
     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_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 = {};
@@ -227,6 +232,7 @@ class TestSdb < Test::Unit::TestCase
     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 = {};