fmalamitsas-aws-s3 0.6.2.1254423625

data/test/acl_test.rb

@@ -0,0 +1,254 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PolicyReadingTest < Test::Unit::TestCase
+  
+  def setup
+    @policy = prepare_policy
+  end
+  
+  def test_policy_owner
+    assert_kind_of Owner, @policy.owner
+    assert_equal 'bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1', @policy.owner.id
+    assert_equal 'mmolina@onramp.net', @policy.owner.display_name
+  end
+  
+  def test_grants
+    assert @policy.grants
+    assert !@policy.grants.empty?
+    grant = @policy.grants.first
+    assert_kind_of ACL::Grant, grant
+    assert_equal 'FULL_CONTROL', grant.permission
+  end
+  
+  def test_grants_have_grantee
+    grant = @policy.grants.first
+    assert grantee = grant.grantee
+    assert_kind_of ACL::Grantee, grantee
+    assert_equal 'bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1', grantee.id
+    assert_equal 'mmolina@onramp.net', grantee.display_name
+    assert_equal 'CanonicalUser', grantee.type
+  end
+  
+  def test_grantee_always_responds_to_email_address
+    assert_nothing_raised do
+      @policy.grants.first.grantee.email_address
+    end
+  end
+  
+  private
+    def prepare_policy
+      ACL::Policy.new(parsed_policy)
+    end
+  
+    def parsed_policy
+      Parsing::XmlParser.new Fixtures::Policies.policy_with_one_grant
+    end
+end
+
+class PolicyWritingTest < PolicyReadingTest
+  
+  def setup
+    policy = prepare_policy
+    # Dump the policy to xml and retranslate it back from the xml then run all the tests in the xml reading
+    # test. This round tripping indirectly asserts that the original xml document is the same as the to_xml
+    # dump.
+    @policy = ACL::Policy.new(Parsing::XmlParser.new(policy.to_xml))
+  end
+  
+end
+
+class PolicyTest < Test::Unit::TestCase
+  def test_building_policy_by_hand
+    policy = grant = grantee = nil
+    assert_nothing_raised do
+      policy                = ACL::Policy.new
+      grant                 = ACL::Grant.new
+      grantee               = ACL::Grantee.new
+      grantee.email_address = 'marcel@vernix.org'
+      grant.permission      = 'READ_ACP'
+      grant.grantee         = grantee
+      policy.grants << grant
+      policy.owner          = Owner.new('id' => '123456789', 'display_name' => 'noradio')
+    end
+    
+    assert_nothing_raised do
+      policy.to_xml
+    end
+    
+    assert !policy.grants.empty?
+    assert_equal 1, policy.grants.size
+    assert_equal 'READ_ACP', policy.grants.first.permission
+  end
+  
+  def test_include?
+    policy = ACL::Policy.new(Parsing::XmlParser.new(Fixtures::Policies.policy_with_one_grant))
+    assert !policy.grants.include?(:public_read)
+    policy.grants << ACL::Grant.grant(:public_read)
+    assert policy.grants.include?(:public_read)
+    
+    assert policy.grants.include?(ACL::Grant.grant(:public_read))
+    [false, 1, '1'].each do |non_grant|
+      assert !policy.grants.include?(non_grant)
+    end
+  end
+  
+  def test_delete
+    policy = ACL::Policy.new(Parsing::XmlParser.new(Fixtures::Policies.policy_with_one_grant))
+    policy.grants << ACL::Grant.grant(:public_read)
+    assert policy.grants.include?(:public_read)
+    assert policy.grants.delete(:public_read)
+    assert !policy.grants.include?(:public_read)
+    [false, 1, '1'].each do |non_grant|
+      assert_nil policy.grants.delete(non_grant)
+    end
+  end
+  
+  def test_grant_list_comparison
+    policy  = ACL::Policy.new
+    policy2 = ACL::Policy.new
+    
+    grant_names = [:public_read, :public_read_acp, :authenticated_write]
+    grant_names.each {|grant_name| policy.grants << ACL::Grant.grant(grant_name)}
+    grant_names.reverse_each {|grant_name| policy2.grants << ACL::Grant.grant(grant_name)}
+    
+    assert_equal policy.grants, policy2.grants
+  end
+end
+
+class GrantTest < Test::Unit::TestCase
+  def test_permission_must_be_valid
+    grant = ACL::Grant.new
+    assert_nothing_raised do
+      grant.permission = 'READ_ACP'
+    end
+    
+    assert_raises(InvalidAccessControlLevel) do
+      grant.permission = 'not a valid permission'
+    end
+  end
+  
+  def test_stock_grants
+    assert_raises(ArgumentError) do
+      ACL::Grant.grant :this_is_not_a_stock_grant
+    end
+    
+    grant = nil
+    assert_nothing_raised do
+      grant = ACL::Grant.grant(:public_read)
+    end
+    
+    assert grant
+    assert_kind_of ACL::Grant, grant
+    assert_equal 'READ', grant.permission
+    assert grant.grantee
+    assert_kind_of ACL::Grantee, grant.grantee
+    assert_equal 'AllUsers', grant.grantee.group
+  end
+end
+
+class GranteeTest < Test::Unit::TestCase
+  def test_type_inference
+    grantee = ACL::Grantee.new
+    
+    assert_nothing_raised do
+      grantee.type
+    end
+    
+    assert_nil grantee.type
+    grantee.group = 'AllUsers'
+    assert_equal 'AllUsers', grantee.group
+    assert_equal 'Group', grantee.type
+    grantee.email_address = 'marcel@vernix.org'
+    assert_equal 'AmazonCustomerByEmail', grantee.type
+    grantee.display_name = 'noradio'
+    assert_equal 'AmazonCustomerByEmail', grantee.type
+    grantee.id = '123456789'
+    assert_equal 'CanonicalUser', grantee.type
+  end
+  
+  def test_type_is_extracted_if_present
+    grantee = ACL::Grantee.new('xsi:type' => 'CanonicalUser')
+    assert_equal 'CanonicalUser', grantee.type
+  end
+  
+  def test_type_representation
+    grantee = ACL::Grantee.new('uri' => 'http://acs.amazonaws.com/groups/global/AllUsers')
+    
+    assert_equal 'AllUsers Group', grantee.type_representation
+    grantee.group = 'AuthenticatedUsers'
+    assert_equal 'AuthenticatedUsers Group', grantee.type_representation
+    grantee.email_address = 'marcel@vernix.org'
+    assert_equal 'marcel@vernix.org', grantee.type_representation
+    grantee.display_name = 'noradio'
+    grantee.id = '123456789'
+    assert_equal 'noradio', grantee.type_representation
+  end
+end
+
+class ACLOptionProcessorTest < Test::Unit::TestCase
+  def test_empty_options
+    options = {}
+    assert_nothing_raised do
+      process! options
+    end
+    assert_equal({}, options)
+  end
+  
+  def test_invalid_access_level
+    options = {:access => :foo}
+    assert_raises(InvalidAccessControlLevel) do
+      process! options
+    end
+  end
+  
+  def test_valid_access_level_is_normalized
+    valid_access_levels = [
+      {:access     => :private},
+      {'access'    => 'private'},
+      {:access     => 'private'},
+      {'access'    => :private},
+      {'x-amz-acl' => 'private'},
+      {:x_amz_acl  => :private},
+      {:x_amz_acl  => 'private'},
+      {'x_amz_acl' => :private}
+    ]
+    
+    valid_access_levels.each do |options|
+      assert_nothing_raised do
+        process! options
+      end
+      assert_equal 'private', acl(options)
+    end
+    
+    valid_hyphenated_access_levels = [
+      {:access     => :public_read},
+      {'access'    => 'public_read'},
+      {'access'    => 'public-read'},
+      {:access     => 'public_read'},
+      {:access     => 'public-read'},
+      {'access'    => :public_read},
+      
+      {'x-amz-acl' => 'public_read'},
+      {:x_amz_acl  => :public_read},
+      {:x_amz_acl  => 'public_read'},
+      {:x_amz_acl  => 'public-read'},
+      {'x_amz_acl' => :public_read}
+    ]
+    
+    valid_hyphenated_access_levels.each do |options|
+      assert_nothing_raised do
+        process! options
+      end
+      assert_equal 'public-read', acl(options)
+    end
+  end
+  
+  private
+    def process!(options)
+      ACL::OptionProcessor.process!(options)
+    end
+    
+    def acl(options)
+      options['x-amz-acl']
+    end
+end

data/test/authentication_test.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class HeaderAuthenticationTest < Test::Unit::TestCase  
+  def test_encoded_canonical
+    signature = Authentication::Signature.new(request, key_id, secret, current_host)
+    assert_equal AmazonDocExampleData::Example1.canonical_string, signature.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example1.signature, signature.send(:encoded_canonical)
+  end
+  
+  def test_authorization_header
+    header = Authentication::Header.new(request, key_id, secret, current_host)
+    assert_equal AmazonDocExampleData::Example1.canonical_string, header.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example1.authorization_header, header
+  end
+  
+  private
+    def request; AmazonDocExampleData::Example1.request end
+    def key_id ; AmazonDocExampleData::Example1.access_key_id end
+    def secret ; AmazonDocExampleData::Example1.secret_access_key end
+    def current_host; AmazonDocExampleData::Example1.current_host end
+end
+
+class QueryStringAuthenticationTest < Test::Unit::TestCase
+  def test_query_string
+    query_string = Authentication::QueryString.new(request, key_id, secret, current_host, :expires_in => 60)
+    assert_equal AmazonDocExampleData::Example3.canonical_string, query_string.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example3.query_string, query_string
+  end
+  
+  def test_query_string_with_explicit_expiry
+    query_string = Authentication::QueryString.new(request, key_id, secret, current_host, :expires => expires)
+    assert_equal expires, query_string.send(:canonical_string).instance_variable_get(:@options)[:expires]
+    assert_equal AmazonDocExampleData::Example3.query_string, query_string
+  end
+  
+  def test_expires_in_is_coerced_to_being_an_integer_in_case_it_is_a_special_integer_proxy
+    # References bug: http://rubyforge.org/tracker/index.php?func=detail&aid=17458&group_id=2409&atid=9356
+    integer_proxy = Class.new do
+      attr_reader :integer
+      def initialize(integer)
+        @integer = integer
+      end
+      
+      def to_int
+        integer
+      end
+    end
+    
+    actual_integer = 25
+    # query_string = Authentication::QueryString.new(request, key_id, secret, :expires_in => integer_proxy.new(actual_integer))
+    query_string = Authentication::QueryString.new(request, key_id, secret, current_host, :expires_in => integer_proxy.new(actual_integer))
+    assert_equal actual_integer, query_string.send(:expires_in)
+  end
+  
+  private
+    def request; AmazonDocExampleData::Example3.request end
+    def key_id ; AmazonDocExampleData::Example3.access_key_id end
+    def secret ; AmazonDocExampleData::Example3.secret_access_key end
+    def expires; AmazonDocExampleData::Example3.expires end
+    def current_host; AmazonDocExampleData::Example1.current_host end
+end
+
+class CanonicalStringTest < Test::Unit::TestCase  
+  def setup
+    @request = Net::HTTP::Post.new('/test')
+    @current_host = 'quotes'
+    @canonical_string = Authentication::CanonicalString.new(@request, @current_host)
+  end
+  
+  def test_path_does_not_include_query_string
+    request = Net::HTTP::Get.new('/test/query/string?foo=bar&baz=quux')
+    assert_equal '/quotes/test/query/string', Authentication::CanonicalString.new(request, @current_host).send(:path)
+    
+    # Make sure things still work when there is *no* query string
+    request = Net::HTTP::Get.new('/')
+    assert_equal '/quotes/', Authentication::CanonicalString.new(request, @current_host).send(:path)
+    request = Net::HTTP::Get.new('/foo/bar')
+    assert_equal '/quotes/foo/bar', Authentication::CanonicalString.new(request, @current_host).send(:path)
+  end
+  
+  def test_path_includes_significant_query_strings
+    significant_query_strings = [
+      ['/test/query/string?acl',             '/quotes/test/query/string?acl'],
+      ['/test/query/string?acl&foo=bar',     '/quotes/test/query/string?acl'],
+      ['/test/query/string?foo=bar&acl',     '/quotes/test/query/string?acl'],
+      ['/test/query/string?acl=foo',         '/quotes/test/query/string?acl'],
+      ['/test/query/string?torrent=foo',     '/quotes/test/query/string?torrent'],
+      ['/test/query/string?logging=foo',     '/quotes/test/query/string?logging'],
+      ['/test/query/string?bar=baz&acl=foo', '/quotes/test/query/string?acl']
+    ]
+    
+    significant_query_strings.each do |uncleaned_path, expected_cleaned_path|
+      assert_equal expected_cleaned_path, Authentication::CanonicalString.new(Net::HTTP::Get.new(uncleaned_path), @current_host).send(:path)
+    end
+  end
+  
+  def test_default_headers_set
+    Authentication::CanonicalString.default_headers.each do |header|
+      assert @canonical_string.headers.include?(header)
+    end
+  end
+  
+  def test_interesting_headers_are_copied_over
+    an_interesting_header = 'content-md5'
+    string_without_interesting_header = Authentication::CanonicalString.new(@request, @current_host)
+    assert string_without_interesting_header.headers[an_interesting_header].empty?
+    
+    # Add an interesting header
+    @request[an_interesting_header] = 'foo'
+    string_with_interesting_header = Authentication::CanonicalString.new(@request, @current_host)
+    assert_equal 'foo', string_with_interesting_header.headers[an_interesting_header]
+  end
+  
+  def test_canonical_string
+    request = AmazonDocExampleData::Example1.request
+    assert_equal AmazonDocExampleData::Example1.canonical_string, Authentication::CanonicalString.new(request, @current_host)
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class BaseTest < Test::Unit::TestCase  
+  def test_connection_established
+    assert_raises(NoConnectionEstablished) do
+      Base.connection
+    end
+    
+    Base.establish_connection!(:access_key_id => '123', :secret_access_key => 'abc')
+    assert_kind_of Connection, Base.connection
+    
+    instance = Base.new
+    assert_equal instance.send(:connection), Base.connection
+    assert_equal instance.send(:http), Base.connection.http
+  end
+  
+  def test_respond_with
+    assert_equal Base::Response, Base.send(:response_class)
+    Base.send(:respond_with, Bucket::Response) do
+      assert_equal Bucket::Response, Base.send(:response_class)
+    end
+    assert_equal Base::Response, Base.send(:response_class)
+  end
+  
+  def test_request_tries_again_when_encountering_an_internal_error
+    mock_connection_for(Bucket, :returns => [
+      # First request is an internal error
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Second request is a success
+      {:body => Fixtures::Buckets.empty_bucket,  :code => 200}
+    ])
+    bucket = nil # Block scope hack
+    assert_nothing_raised do
+      bucket = Bucket.find('marcel')
+    end
+    # Don't call objects 'cause we don't want to make another request
+    assert bucket.object_cache.empty?
+  end
+  
+  def test_request_tries_up_to_three_times
+    mock_connection_for(Bucket, :returns => [
+      # First request is an internal error
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Second request is also an internal error
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Ditto third
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Fourth works
+      {:body => Fixtures::Buckets.empty_bucket,  :code => 200}
+    ])
+    bucket = nil # Block scope hack
+    assert_nothing_raised do
+      bucket = Bucket.find('marcel')
+    end
+    # Don't call objects 'cause we don't want to make another request
+    assert bucket.object_cache.empty?
+  end
+  
+  def test_request_tries_again_three_times_and_gives_up
+    mock_connection_for(Bucket, :returns => [
+      # First request is an internal error
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Second request is also an internal error
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Ditto third
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+      # Ditto fourth
+      {:body => Fixtures::Errors.internal_error, :code => 500, :error => true},
+    ])
+    assert_raises(InternalError) do
+      Bucket.find('marcel')
+    end
+  end
+end
+
+class MultiConnectionsTest < Test::Unit::TestCase
+  class ClassToTestSettingCurrentBucket < Base
+    set_current_bucket_to 'foo'
+  end
+
+  def setup
+    Base.send(:connections).clear
+  end
+  
+  def test_default_connection_options_are_used_for_subsequent_connections    
+    assert !Base.connected?
+    
+    assert_raises(MissingAccessKey) do
+      Base.establish_connection!
+    end
+    
+    assert !Base.connected?
+    
+    assert_raises(NoConnectionEstablished) do
+      Base.connection
+    end
+    
+    assert_nothing_raised do
+      Base.establish_connection!(:access_key_id => '123', :secret_access_key => 'abc')
+    end
+    
+    assert Base.connected?
+    
+    assert_nothing_raised do
+      Base.connection
+    end
+    
+    # All subclasses are currently using the default connection
+    assert_equal Base.connection, Bucket.connection
+    
+    # No need to pass in the required options. The default connection will supply them
+    assert_nothing_raised do
+      Bucket.establish_connection!(:server => 'foo.s3.amazonaws.com')
+    end
+    
+    assert Base.connection != Bucket.connection
+    assert_equal '123', Bucket.connection.access_key_id
+    assert_equal 'foo', Bucket.connection.subdomain
+  end
+  
+  def test_current_bucket
+    Base.establish_connection!(:access_key_id => '123', :secret_access_key => 'abc') 
+    assert_raises(CurrentBucketNotSpecified) do
+      Base.current_bucket
+    end
+    
+    S3Object.establish_connection!(:server => 'foo-bucket.s3.amazonaws.com')
+    assert_nothing_raised do
+      assert_equal 'foo-bucket', S3Object.current_bucket
+    end
+  end
+  
+  def test_setting_the_current_bucket
+    assert_equal 'foo', ClassToTestSettingCurrentBucket.current_bucket
+  end
+end