croaker-aws-s3 0.5.2.20090127001

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

data/test/remote/object_test.rb

@@ -0,0 +1,371 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteS3ObjectTest < Test::Unit::TestCase
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  def test_object
+    key                 = 'testing_s3objects'
+    value               = 'testing'
+    content_type        = 'text/plain'
+    unauthenticated_url = ['http:/', Base.connection.http.address, TEST_BUCKET, key].join('/')
+    
+    # Create an object
+    
+    response = nil
+    assert_nothing_raised do
+      response = S3Object.create(key, value, TEST_BUCKET, :access => :public_read, :content_type => content_type)
+    end
+    
+    # Check response
+    
+    assert response.success?
+    
+    # Extract the object's etag
+    
+    etag = nil
+    assert_nothing_raised do
+      etag = response.etag
+    end
+    
+    assert etag
+    
+    # Confirm we can't create an object unless the bucket is set
+    
+    assert_raises(NoBucketSpecified) do
+      object = S3Object.new
+      object.key = 'hello'
+      object.store
+    end
+    
+    # Fetch newly created object to show it was actually created
+    
+    object = nil
+    assert_nothing_raised do
+      object = S3Object.find(key, TEST_BUCKET)
+    end
+    
+    assert object
+    
+    # Confirm it has the right etag
+    
+    assert_equal etag, object.etag
+    
+    # Check if its owner is properly set
+    
+    assert_nothing_raised do
+      object.owner.display_name
+    end
+    
+    # Confirm we can get the object's key
+    
+    assert_equal key, object.key
+    
+    # Confirm its value was properly set
+    
+    assert_equal value, object.value
+    assert_equal value, S3Object.value(key, TEST_BUCKET)
+    streamed_value = ''
+    assert_nothing_raised do
+      S3Object.stream(key, TEST_BUCKET) do |segment|
+        streamed_value << segment
+      end
+    end
+    
+    assert_equal value, streamed_value
+    
+    # Change its value
+    
+    new_value = "<script>alert('foo');</script>"
+    assert_nothing_raised do
+      object.value = new_value
+    end
+    assert_equal new_value, object.value
+    
+    # Confirm content type was properly set
+    
+    assert_equal content_type, object.content_type
+    
+    # Change its content type
+    
+    new_content_type = 'text/javascript'
+    assert_nothing_raised do
+      object.content_type = new_content_type
+    end
+    
+    assert_equal new_content_type, object.content_type
+    
+    # Test that it is publicly readable
+    
+    response = fetch_object_at(unauthenticated_url)
+    assert (200..299).include?(response.code.to_i)
+    
+    # Confirm that it has no meta data
+    
+    assert object.metadata.empty?
+    
+    # Set some meta data
+    
+    metadata_key   = :secret_sauce
+    metadata_value = "it's a secret"
+    object.metadata[metadata_key] = metadata_value
+    
+    # Persist all changes
+    
+    assert_nothing_raised do
+      object.store
+    end
+    
+    # Refetch the object
+    
+    key = object.key
+    object = nil
+    assert_nothing_raised do
+      object = S3Object.find(key, TEST_BUCKET)
+    end
+    
+    # Confirm all changes were persisted
+    
+    assert object
+    assert_equal key, object.key
+    
+    assert_equal new_content_type, object.content_type
+    
+    assert_equal new_value, object.value
+    assert_equal new_value, object.value(:reload)
+    
+    assert !object.metadata.empty?
+    assert_equal metadata_value, object.metadata[metadata_key]
+    
+    # Change acl
+    
+    assert_nothing_raised do
+      S3Object.create(object.key, object.value, TEST_BUCKET, :access => :private, :content_type => object.content_type)
+    end
+    
+    # Confirm object is no longer publicly readable
+    
+    response = fetch_object_at(unauthenticated_url)
+    assert (400..499).include?(response.code.to_i)
+    
+    # Confirm object is accessible from its authenticated url
+    
+    response = fetch_object_at(object.url)
+    assert (200..299).include?(response.code.to_i)
+    
+    # Copy the object
+    
+    assert_nothing_raised do
+      object.copy('testing_s3objects-copy')
+    end
+    
+    # Confirm the object is identical
+    
+    copy = nil
+    assert_nothing_raised do
+      copy = S3Object.find('testing_s3objects-copy', TEST_BUCKET)
+    end
+    
+    assert copy
+    
+    assert_equal object.value, copy.value
+    assert_equal object.content_type, copy.content_type
+    
+    # Delete object
+    
+    assert_nothing_raised do
+      object.delete
+    end
+    
+    # Confirm we can rename objects
+    
+    renamed_to = copy.key + '-renamed'
+    renamed_value = copy.value
+    assert_nothing_raised do
+      S3Object.rename(copy.key, renamed_to, TEST_BUCKET)
+    end
+    
+    # Confirm renamed copy exists
+    
+    renamed = nil
+    assert_nothing_raised do
+      renamed = S3Object.find(renamed_to, TEST_BUCKET)
+    end
+    
+    assert renamed
+    assert_equal renamed_value, renamed.value
+    
+    # Confirm copy is deleted
+    
+    assert_raises(NoSuchKey) do
+      S3Object.find(copy.key, TEST_BUCKET)
+    end
+    
+    # Confirm that you can not store an object once it is deleted
+    
+    assert_raises(DeletedObject) do
+      object.store
+    end
+    
+    assert_raises(NoSuchKey) do
+      S3Object.find(key, TEST_BUCKET)
+    end
+    
+    # Confirm we can pass in an IO stream and have the uploading sent in chunks
+    
+    response = nil
+    test_file_key = File.basename(TEST_FILE)
+    assert_nothing_raised do
+      response = S3Object.store(test_file_key, open(TEST_FILE), TEST_BUCKET)
+    end
+    assert response.success?
+    
+    assert_equal File.size(TEST_FILE), Integer(S3Object.about(test_file_key, TEST_BUCKET)['content-length'])
+    
+    result = nil
+    assert_nothing_raised do
+      result = S3Object.delete(test_file_key, TEST_BUCKET)
+    end
+    
+    assert result
+  end
+    
+  def test_content_type_inference
+    # Confirm appropriate content type is inferred when not specified
+
+    content_type_objects = {'foo.jpg' => 'image/jpeg', 'no-extension-specified' => 'binary/octet-stream', 'foo.txt' => 'text/plain'}
+    content_type_objects.each_key  do |key|
+      S3Object.store(key, 'fake data', TEST_BUCKET) # No content type explicitly set
+    end
+
+    content_type_objects.each do |key, content_type|
+      assert_equal content_type, S3Object.about(key, TEST_BUCKET)['content-type']
+    end
+    
+    # Confirm we can update the content type
+    
+    assert_nothing_raised do
+      object = S3Object.find('no-extension-specified', TEST_BUCKET)
+      object.content_type = 'application/pdf'
+      object.store
+    end
+    
+    assert_equal 'application/pdf', S3Object.about('no-extension-specified', TEST_BUCKET)['content-type']
+    
+  ensure
+    # Get rid of objects we just created
+    content_type_objects.each_key {|key| S3Object.delete(key, TEST_BUCKET) }
+  end
+  
+  def test_body_can_be_more_than_just_string_or_io
+    require 'stringio'
+    key = 'testing-body-as-string-io'
+    io = StringIO.new('hello there')
+    S3Object.store(key, io, TEST_BUCKET)
+    assert_equal 'hello there', S3Object.value(key, TEST_BUCKET)
+  ensure
+    S3Object.delete(key, TEST_BUCKET)
+  end
+  
+  def test_fetching_information_about_an_object_that_does_not_exist_raises_no_such_key
+    assert_raises(NoSuchKey) do
+      S3Object.about('asdfasdfasdfas-this-does-not-exist', TEST_BUCKET)
+    end
+  end
+  
+  # Regression test for http://developer.amazonwebservices.com/connect/thread.jspa?messageID=49152&tstart=0#49152
+  def test_finding_an_object_with_slashes_in_its_name_does_not_escape_the_slash
+    S3Object.store('rails/1', 'value does not matter', TEST_BUCKET)
+    S3Object.store('rails/1.html', 'value does not matter', TEST_BUCKET)
+    
+    object = nil
+    assert_nothing_raised do
+      object = S3Object.find('rails/1.html', TEST_BUCKET)
+    end
+    
+    assert_equal 'rails/1.html', object.key
+  ensure
+    %w(rails/1 rails/1.html).each {|key| S3Object.delete(key, TEST_BUCKET)}
+  end
+  
+  def test_finding_an_object_with_spaces_in_its_name    
+    assert_nothing_raised do
+      S3Object.store('name with spaces', 'value does not matter', TEST_BUCKET)
+    end
+    
+    object = nil
+    assert_nothing_raised do
+      object = S3Object.find('name with spaces', TEST_BUCKET)
+    end
+    
+    assert object
+    assert_equal 'name with spaces', object.key
+    
+    # Confirm authenticated url is generated correctly despite space in file name
+    
+    response = fetch_object_at(object.url)
+    assert (200..299).include?(response.code.to_i)
+    
+  ensure
+    S3Object.delete('name with spaces', TEST_BUCKET)
+  end
+  
+  def test_copying_an_object_should_copy_over_its_acl_also_if_requested
+    key      = 'copied-objects-inherit-acl'
+    copy_key = key + '2'
+    S3Object.store(key, 'value does not matter', TEST_BUCKET)
+    original_object = S3Object.find(key, TEST_BUCKET)
+    original_object.acl.grants << ACL::Grant.grant(:public_read)
+    original_object.acl.grants << ACL::Grant.grant(:public_read_acp)
+    
+    S3Object.acl(key, TEST_BUCKET, original_object.acl)
+    
+    acl = S3Object.acl(key, TEST_BUCKET)
+    assert_equal 3, acl.grants.size
+    
+    S3Object.copy(key, copy_key, TEST_BUCKET, :copy_acl => true)
+    copied_object = S3Object.find(copy_key, TEST_BUCKET)
+    assert_equal acl.grants, copied_object.acl.grants
+  ensure
+    S3Object.delete(key, TEST_BUCKET)
+    S3Object.delete(copy_key, TEST_BUCKET)
+  end
+  
+  def test_handling_a_path_that_is_not_valid_utf8
+    key = "318597/620065/GTL_75\24300_A600_A610.zip"
+    assert_nothing_raised do
+      S3Object.store(key, 'value does not matter', TEST_BUCKET)
+    end
+    
+    object = nil
+    assert_nothing_raised do
+      object = S3Object.find(key, TEST_BUCKET)
+    end
+
+    assert object
+    
+    url = nil
+    assert_nothing_raised do
+      url = S3Object.url_for(key, TEST_BUCKET)
+    end
+    
+    assert url
+    
+    assert_equal object.value, fetch_object_at(url).body
+  ensure
+    assert_nothing_raised do
+      S3Object.delete(key, TEST_BUCKET)
+    end
+  end
+  
+  private
+    def fetch_object_at(url)
+      Net::HTTP.get_response(URI.parse(url))
+    end
+    
+end

data/test/remote/test_helper.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'uri'
+$:.unshift File.dirname(__FILE__) + '/../../lib'
+require 'aws/s3'
+require_library_or_gem 'breakpoint'
+
+TEST_BUCKET = 'aws-s3-tests'
+TEST_FILE   = File.dirname(__FILE__) + '/test_file.data'
+
+class Test::Unit::TestCase
+  include AWS::S3
+  def establish_real_connection    
+    Base.establish_connection!(
+      :access_key_id     => ENV['AMAZON_ACCESS_KEY_ID'], 
+      :secret_access_key => ENV['AMAZON_SECRET_ACCESS_KEY']
+    )
+  end
+  
+  def disconnect!
+    Base.disconnect
+  end
+  
+  class TestBucket < Bucket
+    set_current_bucket_to TEST_BUCKET
+  end
+  
+  class TestS3Object < S3Object
+    set_current_bucket_to TEST_BUCKET
+  end
+end

data/test/response_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/test_helper'
+class BaseResponseTest < Test::Unit::TestCase 
+  def setup
+    @headers       = {'content-type' => 'text/plain', 'date' => Time.now}
+    @response      = FakeResponse.new()
+    @base_response = Base::Response.new(@response)
+  end
+  
+  def test_status_predicates
+    response = Proc.new {|code| Base::Response.new(FakeResponse.new(:code => code))}
+    assert response[200].success?
+    assert response[300].redirect?
+    assert response[400].client_error?
+    assert response[500].server_error?
+  end
+  
+  def test_headers_passed_along_from_original_response
+    assert_equal @response.headers, @base_response.headers
+    assert_equal @response['date'], @base_response['date']
+    original_headers, new_headers = {}, {}
+    @response.headers.each {|k,v| original_headers[k] = v}
+    @base_response.each {|k,v| new_headers[k] = v}
+    assert_equal original_headers, new_headers
+  end
+end
+
+class ErrorResponseTest < Test::Unit::TestCase
+  def test_error_responses_are_always_in_error
+    assert Error::Response.new(FakeResponse.new).error?
+    assert Error::Response.new(FakeResponse.new(:code => 200)).error?
+    assert Error::Response.new(FakeResponse.new(:headers => {'content-type' => 'text/plain'})).error?
+  end
+end
+
+class S3ObjectResponseTest < Test::Unit::TestCase
+  def test_etag_extracted
+    mock_connection_for(S3Object, :returns => {:headers => {"etag" => %("acbd18db4cc2f85cedef654fccc4a4d8")}}).twice # once for the connection itself and the second time to verify the subdomain..
+    object_response = S3Object.create('name_does_not_matter', 'data does not matter', 'bucket does not matter')
+    assert_equal "acbd18db4cc2f85cedef654fccc4a4d8", object_response.etag 
+  end
+end
+
+class ResponseClassFinderTest < Test::Unit::TestCase
+  class CampfireBucket < Bucket
+  end
+  
+  class BabyBase < Base
+  end
+  
+  def test_on_base
+    assert_equal Base::Response, FindResponseClass.for(Base)
+    assert_equal Base::Response, FindResponseClass.for(AWS::S3::Base)
+    
+  end
+  
+  def test_on_subclass_with_corresponding_response_class
+    assert_equal Bucket::Response, FindResponseClass.for(Bucket)
+    assert_equal Bucket::Response, FindResponseClass.for(AWS::S3::Bucket)
+  end
+  
+  def test_on_subclass_with_intermediary_parent_that_has_corresponding_response_class
+    assert_equal Bucket::Response, FindResponseClass.for(CampfireBucket)
+  end
+  
+  def test_on_subclass_with_no_corresponding_response_class_and_no_intermediary_parent
+    assert_equal Base::Response, FindResponseClass.for(BabyBase)
+  end
+end

data/test/service_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ServiceTest < Test::Unit::TestCase  
+  def test_bucket_list_with_empty_bucket_list
+    mock_connection_for(Service, :returns => {:body => Fixtures::Buckets.empty_bucket_list, :code => 200})
+    list = Service.buckets(:reload)
+    assert_equal [], list
+  end
+
+  def test_bucket_list_with_bucket_list_containing_one_bucket
+    mock_connection_for(Service, :returns => {:body => Fixtures::Buckets.bucket_list_with_one_bucket, :code => 200})
+    list = Service.buckets(:reload)
+    assert_equal 1, list.size
+    assert_equal 'marcel_molina', list.first.name
+  end
+
+  def test_bucket_list_with_bucket_list_containing_more_than_one_bucket
+    mock_connection_for(Service, :returns => {:body => Fixtures::Buckets.bucket_list_with_more_than_one_bucket, :code => 200})    
+    list = Service.buckets(:reload)
+    assert_equal 2, list.size
+    assert_equal %w(marcel_molina marcel_molina_jr), list.map {|bucket| bucket.name}.sort
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,111 @@
+require 'test/unit'
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'aws/s3'
+require File.dirname(__FILE__) + '/mocks/fake_response'
+require File.dirname(__FILE__) + '/fixtures'
+require_library_or_gem 'ruby-debug'
+require_library_or_gem 'flexmock'
+require_library_or_gem 'flexmock/test_unit'
+
+
+# Data copied from http://docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAuthentication.html
+module AmazonDocExampleData
+  module Example1
+    module_function
+    
+      def request
+        request = Net::HTTP::Put.new('/quotes/nelson')
+        request['Content-Md5']       = 'c8fdb181845a4ca6b8fec737b3581d76'
+        request['Content-Type']      = 'text/html'
+        request['Date']              = 'Thu, 17 Nov 2005 18:49:58 GMT'
+        request['X-Amz-Meta-Author'] = 'foo@bar.com'
+        request['X-Amz-Magic']       = 'abracadabra'
+        request
+      end
+  
+      def canonical_string
+        "PUT\nc8fdb181845a4ca6b8fec737b3581d76\ntext/html\nThu, 17 Nov 2005 18:49:58 GMT\nx-amz-magic:abracadabra\nx-amz-meta-author:foo@bar.com\n/quotes/nelson"
+      end
+      
+      def access_key_id
+        '44CF9590006BF252F707'
+      end
+      
+      def secret_access_key
+        'OtxrzxIsfpFjA7SwPzILwy8Bw21TLhquhboDYROV'
+      end
+      
+      def signature
+        'jZNOcbfWmD/A/f3hSvVzXZjM2HU='
+      end
+      
+      def authorization_header
+        'AWS 44CF9590006BF252F707:jZNOcbfWmD/A/f3hSvVzXZjM2HU='
+      end
+  end
+  
+  module Example3
+    module_function
+    
+      def request
+        request = Net::HTTP::Get.new('/quotes/nelson')
+        request['Date'] = date
+        request
+      end
+      
+      def date
+        'Thu Mar  9 01:24:20 CST 2006'
+      end
+      
+      def access_key_id
+        Example1.access_key_id
+      end
+      
+      def secret_access_key
+        Example1.secret_access_key
+      end
+      
+      def expires
+        1141889120
+      end
+      
+      def query_string
+        'AWSAccessKeyId=44CF9590006BF252F707&Expires=1141889120&Signature=vjbyPxybdZaNmGa%2ByT272YEAiv4%3D'
+      end
+      
+      def canonical_string
+        "GET\n\n\n1141889120\n/quotes/nelson"
+      end
+      
+  end
+end
+
+class Test::Unit::TestCase
+  include AWS::S3
+  
+  def sample_proxy_settings
+    {:host => 'http://google.com', :port => 8080, :user => 'marcel', :password => 'secret'}
+  end
+  
+  def mock_connection_for(klass, options = {})
+    data = options[:returns]
+    return_values = case data
+      when Hash
+        FakeResponse.new(data)
+      when Array
+        data.map {|hash| FakeResponse.new(hash)}
+      else
+        abort "Response data for mock connection must be a Hash or an Array. Was #{data.inspect}."
+      end
+    
+    connection = flexmock('Mock connection') do |mock|
+      mock.should_receive(:request).and_return(*return_values).at_least.once
+      
+      # CHANGED: Make sure that no real connection is established
+      mock.should_receive("is_for_bucket?").and_return(true)
+      mock.should_receive("has_subdomain?").and_return(false)
+    end
+
+    flexmock(klass).should_receive(:connection).and_return(connection)
+  end
+end