aws-s3-instructure 0.6.2.1319222580

data/test/parsing_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TypecastingTest < Test::Unit::TestCase
+  # Make it easier to call methods in tests
+  Parsing::Typecasting.public_instance_methods.each do |method|
+    Parsing::Typecasting.send(:module_function, method)
+  end
+  
+  def test_array_with_one_element_that_is_a_hash
+    value = [{'Available' => 'true'}]
+    assert_equal [{'available' => true}], Parsing::Typecasting.typecast(value)
+  end
+  
+  def test_hash_with_one_key_whose_value_is_an_array
+    value = {
+      'Bucket' => 
+        [ 
+          {'Available' => 'true'} 
+        ] 
+    }
+    
+    expected = {
+      'bucket' => 
+        [
+          {'available' => true}
+        ]
+    }
+    assert_equal expected, Parsing::Typecasting.typecast(value)
+  end
+  
+end
+
+class XmlParserTest < Test::Unit::TestCase
+  def test_bucket_is_always_forced_to_be_an_array_unless_empty
+    one_bucket    = Parsing::XmlParser.new(Fixtures::Buckets.bucket_list_with_one_bucket)
+    more_than_one = Parsing::XmlParser.new(Fixtures::Buckets.bucket_list_with_more_than_one_bucket)
+    
+    [one_bucket, more_than_one].each do |bucket_list|
+      assert_kind_of Array, bucket_list['buckets']['bucket']
+    end
+    
+    no_buckets    = Parsing::XmlParser.new(Fixtures::Buckets.empty_bucket_list)
+    assert no_buckets.has_key?('buckets')
+    assert_nil no_buckets['buckets']
+  end
+  
+  def test_bucket_contents_are_forced_to_be_an_array_unless_empty
+    one_key       = Parsing::XmlParser.new(Fixtures::Buckets.bucket_with_one_key)
+    more_than_one = Parsing::XmlParser.new(Fixtures::Buckets.bucket_with_more_than_one_key)
+    [one_key, more_than_one].each do |bucket_with_contents|
+      assert_kind_of Array, bucket_with_contents['contents']
+    end
+    
+    no_keys = Parsing::XmlParser.new(Fixtures::Buckets.empty_bucket)
+    assert !no_keys.has_key?('contents')
+  end
+  
+  def test_policy_grants_are_always_an_array
+    policy = Parsing::XmlParser.new(Fixtures::Policies.policy_with_one_grant)
+    assert_kind_of Array, policy['access_control_list']['grant']
+  end
+  
+  def test_empty_xml_response_is_not_parsed
+    assert_equal({}, Parsing::XmlParser.new(''))
+  end
+end

data/test/remote/acl_test.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteACLTest < Test::Unit::TestCase
+  
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  def test_acl
+    Bucket.create(TEST_BUCKET) # Wipe out the existing bucket's ACL
+      
+    bucket_policy = Bucket.acl(TEST_BUCKET)
+    assert_equal 1, bucket_policy.grants.size
+    assert !bucket_policy.grants.include?(:public_read_acp)
+    
+    bucket_policy.grants << ACL::Grant.grant(:public_read_acp)
+    
+    assert_nothing_raised do
+      Bucket.acl(TEST_BUCKET, bucket_policy)
+    end
+    
+    bucket = Bucket.find(TEST_BUCKET)
+    assert bucket.acl.grants.include?(:public_read_acp)
+
+    bucket.acl.grants.pop # Get rid of the newly added grant
+    
+    assert !bucket.acl.grants.include?(:public_read_acp)
+    bucket.acl(bucket.acl) # Update its acl
+    assert Service.response.success?
+    
+    bucket_policy = Bucket.acl(TEST_BUCKET)
+    assert_equal 1, bucket_policy.grants.size
+    assert !bucket_policy.grants.include?(:public_read_acp)
+    
+    S3Object.store('testing-acls', 'the test data', TEST_BUCKET, :content_type => 'text/plain')
+    acl = S3Object.acl('testing-acls', TEST_BUCKET)
+    
+    # Confirm object has the default policy 
+    
+    assert !acl.grants.empty?
+    assert_equal 1, acl.grants.size
+    grant = acl.grants.first
+    
+    assert_equal 'FULL_CONTROL', grant.permission
+    
+    grantee = grant.grantee
+    
+    assert acl.owner.id
+    assert acl.owner.display_name
+    assert grantee.id
+    assert grantee.display_name
+    
+    assert_equal acl.owner.id, grantee.id
+    assert_equal acl.owner.display_name, grantee.display_name
+    
+    assert_equal Owner.current, acl.owner
+    
+    
+    # Manually add read access to an Amazon customer by email address
+    
+    new_grant                       = ACL::Grant.new
+    new_grant.permission            = 'READ'
+    new_grant_grantee               = ACL::Grantee.new
+    new_grant_grantee.email_address = 'marcel@vernix.org'
+    new_grant.grantee = new_grant_grantee
+    acl.grants << new_grant
+    
+    assert_nothing_raised do
+      S3Object.acl('testing-acls', TEST_BUCKET, acl)
+    end
+    
+    # Confirm the acl was updated successfully
+    
+    assert Service.response.success?
+    
+    acl = S3Object.acl('testing-acls', TEST_BUCKET)
+    assert !acl.grants.empty?
+    assert_equal 2, acl.grants.size
+    new_grant = acl.grants.last
+    assert_equal 'READ', new_grant.permission
+    
+    # Confirm instance method has same result
+    
+    assert_equal acl.grants, S3Object.find('testing-acls', TEST_BUCKET).acl.grants
+    
+    # Get rid of the grant we just added
+    
+    acl.grants.pop
+    
+    # Confirm acl class method sees that the bucket option is being used to put a new acl
+    
+    assert_nothing_raised do
+      TestS3Object.acl('testing-acls', acl)
+    end
+    
+    assert Service.response.success?
+    
+    acl = TestS3Object.acl('testing-acls')
+    
+    # Confirm added grant was removed from the policy
+    
+    assert !acl.grants.empty?
+    assert_equal 1, acl.grants.size
+    grant = acl.grants.first
+    assert_equal 'FULL_CONTROL', grant.permission
+    
+    assert_nothing_raised do
+      S3Object.delete('testing-acls', TEST_BUCKET)
+    end
+    
+    assert Service.response.success?
+  end
+end

data/test/remote/bittorrent_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteBittorrentTest < Test::Unit::TestCase
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  def test_bittorrent
+    bt_test_key = 'testing-bittorrent'
+    S3Object.create(bt_test_key, 'foo', TEST_BUCKET)
+    
+    # Confirm we can fetch a bittorrent file for this object
+    
+    torrent_file = nil
+    assert_nothing_raised do
+      torrent_file = S3Object.torrent_for(bt_test_key, TEST_BUCKET)
+    end
+    assert torrent_file
+    assert torrent_file['tracker']
+    
+    # Make object accessible to the public via a torrent
+    
+    policy = S3Object.acl(bt_test_key, TEST_BUCKET)
+    
+    assert !policy.grants.include?(:public_read)
+    
+    assert_nothing_raised do
+      S3Object.grant_torrent_access_to(bt_test_key, TEST_BUCKET)
+    end
+    
+    policy = S3Object.acl(bt_test_key, TEST_BUCKET)
+    
+    assert policy.grants.include?(:public_read)
+    
+    # Confirm instance method wraps class method
+    
+    assert_equal torrent_file, S3Object.find(bt_test_key, TEST_BUCKET).torrent 
+    
+    S3Object.delete(bt_test_key, TEST_BUCKET)
+  end
+end

data/test/remote/bucket_test.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteBucketTest < Test::Unit::TestCase
+  
+  def setup
+    establish_real_connection
+    assert Bucket.find(TEST_BUCKET).delete_all
+  end
+  
+  def teardown
+    disconnect!
+  end
+
+  def test_bucket
+    # Fetch the testing bucket
+    
+    bucket = nil
+    assert_nothing_raised do
+      bucket = Bucket.find(TEST_BUCKET)
+    end
+    
+    assert bucket
+    
+    # Confirm we can fetch the bucket implicitly
+    
+    bucket = nil
+    assert_nothing_raised do
+      bucket = TestBucket.find
+    end
+    
+    assert bucket
+    
+    # Confirm the bucket has the right name
+    
+    assert_equal TEST_BUCKET, bucket.name
+    
+    assert bucket.empty?
+    assert_equal 0, bucket.size
+    
+    # Add some files to the bucket
+    
+    assert_nothing_raised do
+      %w(a m z).each do |file_name|
+        S3Object.create(file_name, file_name, bucket.name, :content_type => 'text/plain')
+      end
+    end
+    
+    # Confirm that we can reload the objects
+    
+    assert_nothing_raised do
+      bucket.objects(:reload)
+    end
+    
+    assert !bucket.empty?
+    assert_equal 3, bucket.size
+    
+    assert_nothing_raised do
+      bucket.objects(:marker => 'm')
+    end
+
+    assert_equal 1, bucket.size
+    assert bucket['z']
+    
+    assert_equal 1, Bucket.find(TEST_BUCKET, :max_keys => 1).size
+    
+    assert_nothing_raised do
+      bucket.objects(:reload)
+    end
+    
+    assert_equal 3, bucket.size
+    
+    # Ensure the reloaded buckets have been repatriated
+    
+    assert_equal bucket, bucket.objects.first.bucket
+    
+    # Confirm that we can delete one of the objects and it will be removed
+    
+    object_to_be_deleted = bucket.objects.last
+    assert_nothing_raised do
+      object_to_be_deleted.delete
+    end
+    
+    assert !bucket.objects.include?(object_to_be_deleted)
+    
+    # Confirm that we can add an object
+    
+    object = bucket.new_object(:value => 'hello')
+    
+    assert_raises(NoKeySpecified) do
+      object.store
+    end
+    
+    object.key = 'abc'
+    assert_nothing_raised do
+      object.store
+    end
+    
+    assert bucket.objects.include?(object)
+    
+    # Confirm that the object is still there after reloading its objects
+    
+    assert_nothing_raised do
+      bucket.objects(:reload)
+    end 
+    assert bucket.objects.include?(object)
+    
+    # Check that TestBucket has the same objects fetched implicitly
+    
+    assert_equal bucket.objects, TestBucket.objects
+    
+    # Empty out bucket
+    
+    assert_nothing_raised do
+      bucket.delete_all
+    end
+    
+    assert bucket.empty?
+    
+    bucket = nil
+    assert_nothing_raised do
+      bucket = Bucket.find(TEST_BUCKET)
+    end
+    
+    assert bucket.empty?    
+  end
+  
+  def test_bucket_name_is_switched_with_options_when_bucket_is_implicit_and_options_are_passed
+    Object.const_set(:ImplicitlyNamedBucket, Class.new(Bucket))
+    ImplicitlyNamedBucket.current_bucket = TEST_BUCKET
+    assert ImplicitlyNamedBucket.objects.empty?
+    
+    %w(a b c).each {|key| S3Object.store(key, 'value does not matter', TEST_BUCKET)}
+    
+    assert_equal 3, ImplicitlyNamedBucket.objects.size
+    
+    objects = nil
+    assert_nothing_raised do
+      objects = ImplicitlyNamedBucket.objects(:max_keys => 1)
+    end
+    
+    assert objects
+    assert_equal 1, objects.size
+  ensure
+    %w(a b c).each {|key| S3Object.delete(key, TEST_BUCKET)}
+  end
+end

data/test/remote/logging_test.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteLoggingTest < Test::Unit::TestCase
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  def test_logging
+    Bucket.create(TEST_BUCKET) # Clear out any custom grants
+    
+    # Confirm that logging is not enabled on the test bucket
+    
+    assert !Bucket.logging_enabled_for?(TEST_BUCKET)
+    assert !Bucket.find(TEST_BUCKET).logging_enabled?
+    
+    assert_equal [], Bucket.logs_for(TEST_BUCKET)
+    
+    # Confirm the current bucket doesn't have logging grants
+    
+    policy = Bucket.acl(TEST_BUCKET)
+    assert !policy.grants.include?(:logging_read_acp)
+    assert !policy.grants.include?(:logging_write)
+    
+    # Confirm that we can enable logging
+    
+    assert_nothing_raised do
+      Bucket.enable_logging_for TEST_BUCKET
+    end
+    
+    # Confirm enabling logging worked
+    
+    assert Service.response.success?
+        
+    assert Bucket.logging_enabled_for?(TEST_BUCKET)
+    assert Bucket.find(TEST_BUCKET).logging_enabled?
+    
+    # Confirm the appropriate grants were added
+    
+    policy = Bucket.acl(TEST_BUCKET)
+    assert policy.grants.include?(:logging_read_acp)
+    assert policy.grants.include?(:logging_write)
+    
+    # Confirm logging status used defaults
+    
+    logging_status = Bucket.logging_status_for TEST_BUCKET
+    assert_equal TEST_BUCKET, logging_status.target_bucket
+    assert_equal 'log-', logging_status.target_prefix
+    
+    # Confirm we can update the logging status
+    
+    logging_status.target_prefix = 'access-log-'
+    
+    assert_nothing_raised do
+      Bucket.logging_status_for TEST_BUCKET, logging_status
+    end
+    
+    assert Service.response.success?
+    
+    logging_status = Bucket.logging_status_for TEST_BUCKET
+    assert_equal 'access-log-', logging_status.target_prefix
+    
+    # Confirm we can make a request for the bucket's logs
+    
+    assert_nothing_raised do
+      Bucket.logs_for TEST_BUCKET
+    end
+    
+    # Confirm we can disable logging
+    
+    assert_nothing_raised do
+      Bucket.disable_logging_for(TEST_BUCKET)
+    end
+    
+    assert Service.response.success?
+    
+    assert !Bucket.logging_enabled_for?(TEST_BUCKET)
+  end
+end