croaker-aws-s3 0.5.2.20090127001

data/test/logging_test.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LoggingStatusReadingTest < Test::Unit::TestCase
+  
+  def setup
+    @disabled   = logging_status(:logging_disabled)
+    @enabled    = logging_status(:logging_enabled)
+    @new_status = Logging::Status.new('target_bucket' => 'foo', 'target_prefix' => 'access-log-')
+  end
+  
+  def test_logging_enabled?
+    assert !@disabled.logging_enabled?
+    assert !@new_status.logging_enabled?
+    assert @enabled.logging_enabled?
+  end
+  
+  def test_passing_in_prefix_and_bucket
+    assert_equal 'foo', @new_status.target_bucket
+    assert_equal 'access-log-', @new_status.target_prefix
+    assert !@new_status.logging_enabled?
+  end
+  
+  private
+    def logging_status(fixture)
+      Logging::Status.new(Parsing::XmlParser.new(Fixtures::Logging[fixture.to_s]))
+    end
+end
+
+class LoggingStatusWritingTest < LoggingStatusReadingTest
+  def setup
+    super
+    @disabled = Logging::Status.new(Parsing::XmlParser.new(@disabled.to_xml))
+    @enabled  = Logging::Status.new(Parsing::XmlParser.new(@enabled.to_xml))
+  end
+end
+
+class LogTest < Test::Unit::TestCase
+  def test_value_converted_to_log_lines
+    log_object = S3Object.new
+    log_object.value = Fixtures::Logs.simple_log.join
+    log = Logging::Log.new(log_object)
+    assert_nothing_raised do
+      log.lines
+    end
+    
+    assert_equal 2, log.lines.size
+    assert_kind_of Logging::Log::Line, log.lines.first
+    assert_equal 'marcel', log.lines.first.bucket
+  end
+end
+
+class LogLineTest < Test::Unit::TestCase
+  def setup
+    @line = Logging::Log::Line.new(Fixtures::Loglines.bucket_get)
+  end
+  
+  def test_field_accessors
+    expected_results = {
+      :owner            => Owner.new('id' => 'bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1'),
+      :bucket           => 'marcel',
+      :time             => Time.parse('11/14/2006 06:36:48 +0000'),
+      :remote_ip        => '67.165.183.125',
+      :request_id       => '8B5297D428A05432',
+      :requestor        => Owner.new('id' => 'bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1'),
+      :operation        => 'REST.GET.BUCKET',
+      :key              => nil,
+      :request_uri      => 'GET /marcel HTTP/1.1',
+      :http_status      => 200,
+      :error_code       => nil,
+      :bytes_sent       => 4534,
+      :object_size      => nil,
+      :total_time       => 398,
+      :turn_around_time => 395,
+      :referrer         => nil,
+      :user_agent       => nil
+    }
+     
+     expected_results.each do |field, expected|
+       assert_equal expected, @line.send(field)
+     end
+     
+     assert_equal expected_results, @line.attributes
+   end
+   
+  def test_user_agent
+    line = Logging::Log::Line.new(Fixtures::Loglines.browser_get)
+    assert_equal 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en-US; rv:1.8.1) Gecko/20061010 Firefox/2.0', line.user_agent
+  end
+end

data/test/mocks/fake_response.rb

@@ -0,0 +1,26 @@
+module AWS
+  module S3
+    class FakeResponse
+      attr_reader :code, :body, :headers
+      def initialize(options = {})
+        @code    = options.delete(:code)  || 200 
+        @body    = options.delete(:body)  || ''
+        @headers = {'content-type' => 'application/xml'}.merge(options.delete(:headers) || {})
+      end
+
+      # For ErrorResponse
+      def response
+        body
+      end
+      
+      def [](header)
+        headers[header]
+      end
+      
+      def each(&block)
+        headers.each(&block)
+      end
+      alias_method :each_header, :each
+    end
+  end
+end

data/test/object_test.rb

@@ -0,0 +1,205 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ObjectTest < Test::Unit::TestCase
+  def setup
+    bucket  = Bucket.new(Parsing::XmlParser.new(Fixtures::Buckets.bucket_with_one_key))
+    @object = bucket.objects.first
+  end
+  
+  def test_header_settings_reader_and_writer
+    headers = {'content-type' => 'text/plain'}
+    mock_connection_for(S3Object, :returns => {:headers => headers})
+    
+    assert_nothing_raised do
+      @object.content_type
+    end
+  
+    assert_equal 'text/plain', @object.content_type
+  
+    assert_nothing_raised do
+      @object.content_type = 'image/jpg'
+    end
+  
+    assert_equal 'image/jpg', @object.content_type
+  
+    assert_raises(NoMethodError) do
+      @object.non_existant_header_setting
+    end
+  end
+  
+  def test_key_name_validation
+    assert_raises(InvalidKeyName) do
+      S3Object.create(nil, '', 'marcel')
+    end
+    
+    assert_raises(InvalidKeyName) do
+      huge_name = 'a' * 1500
+      S3Object.create(huge_name, '', 'marcel')
+    end
+  end
+  
+  def test_content_type_inference
+    [
+      ['foo.jpg',  {},                             'image/jpeg'],
+      ['foo.txt',  {},                             'text/plain'],
+      ['foo',      {},                             nil],
+      ['foo.asdf', {},                             nil],
+      ['foo.jpg',  {:content_type => nil},         nil],
+      ['foo',      {:content_type => 'image/jpg'}, 'image/jpg'],
+      ['foo.jpg',  {:content_type => 'image/png'}, 'image/png'],
+      ['foo.asdf', {:content_type => 'image/jpg'}, 'image/jpg']
+    ].each do |key, options, content_type|
+      S3Object.send(:infer_content_type!, key, options)
+      assert_equal content_type, options[:content_type]
+    end
+  end
+  
+  def test_object_has_owner
+    assert_kind_of Owner, @object.owner 
+  end
+  
+  def test_owner_attributes_are_accessible
+    owner = @object.owner
+    assert owner.id
+    assert owner.display_name
+    assert_equal 'bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1', owner.id
+    assert_equal 'mmolina@onramp.net', owner.display_name
+  end
+  
+  def test_only_valid_attributes_accessible
+    assert_raises(NoMethodError) do
+      @object.owner.foo
+    end
+  end
+  
+  def test_fetching_object_value_generates_value_object
+    mock_connection_for(S3Object, :returns => {:body => 'hello!'})
+    value = S3Object.value('foo', 'bar')
+    assert_kind_of S3Object::Value, value
+    assert_equal 'hello!', value
+  end
+  
+  def test_fetching_file_by_name_raises_when_heuristic_fails
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
+    assert_raises(NoSuchKey) do
+      S3Object.find('not_tongue_overload.jpg', 'marcel_molina')
+    end
+    
+    object = nil # Block scoping
+    assert_nothing_raised do
+      object = S3Object.find('tongue_overload.jpg', 'marcel_molina')
+    end
+    assert_kind_of S3Object, object
+    assert_equal 'tongue_overload.jpg', object.key
+  end
+  
+  def test_about
+    headers = {'content-size' => '12345', 'date' => Time.now.httpdate, 'content-type' => 'application/xml'}
+    mock_connection_for(S3Object, :returns => [
+      {:headers => headers},
+      {:code    => 404}
+      ]
+    )
+    about = S3Object.about('foo', 'bar')
+    assert_kind_of S3Object::About, about
+    assert_equal headers, about
+    
+    assert_raises(NoSuchKey) do
+      S3Object.about('foo', 'bar')
+    end
+  end
+  
+  def test_can_tell_that_an_s3object_does_not_exist
+    mock_connection_for(S3Object, :returns => {:code => 404})
+    assert_equal false, S3Object.exists?('foo', 'bar')
+  end
+  
+  def test_can_tell_that_an_s3object_exists
+    mock_connection_for(S3Object, :returns => {:code => 200})
+    assert_equal true, S3Object.exists?('foo', 'bar')
+  end
+  
+  def test_s3object_equality
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_more_than_one_key})
+    file1, file2 = Bucket.objects('does not matter')
+    assert file1 == file1
+    assert file2 == file2
+    assert !(file1 == file2) # /!\ Parens required /!\
+  end
+  
+  def test_inspect
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
+    object = S3Object.find('tongue_overload.jpg', 'bucket does not matter')
+    assert object.path
+    assert_nothing_raised { object.inspect }
+    assert object.inspect[object.path]
+  end
+ 
+  def test_etag
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
+    file = S3Object.find('tongue_overload.jpg', 'bucket does not matter')
+    assert file.etag
+    assert_equal 'f21f7c4e8ea6e34b268887b07d6da745', file.etag
+  end
+ 
+  def test_fetching_information_about_an_object_that_does_not_exist_raises_no_such_key
+    mock_connection_for(S3Object, :returns => {:body => '', :code => 404})
+    assert_raises(NoSuchKey) do
+      S3Object.about('asdfasdfasdfas-this-does-not-exist', 'bucket does not matter')
+    end
+  end
+end
+
+class MetadataTest < Test::Unit::TestCase
+  def setup
+    @metadata = S3Object::Metadata.new(Fixtures::Headers.headers_including_one_piece_of_metadata)
+  end
+    
+  def test_only_metadata_is_extracted
+    assert @metadata.to_headers.size == 1
+    assert @metadata.to_headers['x-amz-meta-test']
+    assert_equal 'foo', @metadata.to_headers['x-amz-meta-test']
+  end
+  
+  def test_setting_new_metadata_normalizes_name
+    @metadata[:bar] = 'baz'
+    assert @metadata.to_headers.include?('x-amz-meta-bar')
+    @metadata['baz'] = 'quux'
+    assert @metadata.to_headers.include?('x-amz-meta-baz')
+    @metadata['x-amz-meta-quux'] = 'whatever'
+    assert @metadata.to_headers.include?('x-amz-meta-quux')
+  end
+  
+  def test_clobbering_existing_header
+    @metadata[:bar] = 'baz'
+    assert_equal 'baz', @metadata.to_headers['x-amz-meta-bar']
+    @metadata[:bar] = 'quux'
+    assert_equal 'quux', @metadata.to_headers['x-amz-meta-bar']
+    @metadata['bar'] = 'foo'
+    assert_equal 'foo', @metadata.to_headers['x-amz-meta-bar']
+    @metadata['x-amz-meta-bar'] = 'bar'
+    assert_equal 'bar', @metadata.to_headers['x-amz-meta-bar']
+  end
+  
+  def test_invalid_metadata
+    @metadata[:invalid_header] = ' ' * (S3Object::Metadata::SIZE_LIMIT + 1)
+    assert_raises InvalidMetadataValue do
+      @metadata.to_headers
+    end
+  end
+end
+
+class ValueTest < Test::Unit::TestCase
+  def setup
+    @response = FakeResponse.new(:body => 'hello there')
+    @value    = S3Object::Value.new(@response)
+  end
+  
+  def test_value_is_set_to_response_body
+    assert_equal @response.body, @value
+  end
+  
+  def test_response_is_accessible_from_value_object
+    assert_equal @response, @value.response
+  end
+end

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