aliyun-oss-rails4 0.7.0.1448446959

data/test/remote/acl_test.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+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) 
+    Bucket.acl(TEST_BUCKET, :private) # Wipe out the existing bucket's ACL
+      
+    bucket_policy = Bucket.acl(TEST_BUCKET)
+    assert_equal 'private', bucket_policy
+    
+    assert_nothing_raised do
+      Bucket.acl(TEST_BUCKET, :public_read)
+    end
+    
+    bucket = Bucket.find(TEST_BUCKET)
+    assert_equal 'public-read', bucket.acl
+  end
+end

data/test/remote/bucket_test.rb

@@ -0,0 +1,147 @@
+# -*- encoding : utf-8 -*-
+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|
+        OSSObject.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| OSSObject.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| OSSObject.delete(key, TEST_BUCKET)}
+  end
+end

data/test/remote/logging_test.rb

@@ -0,0 +1,86 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteLoggingTest < Test::Unit::TestCase
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  #TODO 日记功能API不确定
+=begin
+  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
+end

data/test/remote/object_test.rb

@@ -0,0 +1,350 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+
+class RemoteOSSObjectTest < Test::Unit::TestCase
+  def setup
+    establish_real_connection
+  end
+  
+  def teardown
+    disconnect!
+  end
+  
+  def test_object
+    key                 = 'testing_ossobjects'
+    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 = OSSObject.create(key, value, TEST_BUCKET, :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 = OSSObject.new
+      object.key = 'hello'
+      object.store
+    end
+    
+    # Fetch newly created object to show it was actually created
+    
+    object = nil
+    assert_nothing_raised do
+      object = OSSObject.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, OSSObject.value(key, TEST_BUCKET)
+    streamed_value = ''
+    assert_nothing_raised do
+      OSSObject.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
+    
+    Bucket.acl(TEST_BUCKET, :public_read)
+    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 = OSSObject.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
+    
+    Bucket.acl(TEST_BUCKET, :private)
+    
+    # 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_ossobjects-copy')
+    end
+    
+    # Confirm the object is identical
+    
+    copy = nil
+    assert_nothing_raised do
+      copy = OSSObject.find('testing_ossobjects-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
+      OSSObject.rename(copy.key, renamed_to, TEST_BUCKET)
+    end
+    
+    # Confirm renamed copy exists
+    
+    renamed = nil
+    assert_nothing_raised do
+      renamed = OSSObject.find(renamed_to, TEST_BUCKET)
+    end
+    
+    assert renamed
+    assert_equal renamed_value, renamed.value
+    
+    # Confirm copy is deleted
+    
+    assert_raises(NoSuchKey) do
+      OSSObject.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
+      OSSObject.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 = OSSObject.store(test_file_key, open(TEST_FILE), TEST_BUCKET)
+    end
+    assert response.success?
+    
+    assert_equal File.size(TEST_FILE), Integer(OSSObject.about(test_file_key, TEST_BUCKET)['content-length'])
+    
+    result = nil
+    assert_nothing_raised do
+      result = OSSObject.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|
+      OSSObject.store(key, 'fake data', TEST_BUCKET) # No content type explicitly set
+    end
+
+    content_type_objects.each do |key, content_type|
+      assert_equal content_type, OSSObject.about(key, TEST_BUCKET)['content-type']
+    end
+    
+    # Confirm we can update the content type
+    
+    assert_nothing_raised do
+      object = OSSObject.find('no-extension-specified', TEST_BUCKET)
+      object.content_type = 'application/pdf'
+      object.store
+    end
+    
+    assert_equal 'application/pdf', OSSObject.about('no-extension-specified', TEST_BUCKET)['content-type']
+    
+  ensure
+    # Get rid of objects we just created
+    content_type_objects.each_key {|key| OSSObject.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')
+    OSSObject.store(key, io, TEST_BUCKET)
+    assert_equal 'hello there', OSSObject.value(key, TEST_BUCKET)
+  ensure
+    OSSObject.delete(key, TEST_BUCKET)
+  end
+  
+  def test_fetching_information_about_an_object_that_does_not_exist_raises_no_such_key
+    assert_raises(NoSuchKey) do
+      OSSObject.about('asdfasdfasdfas-this-does-not-exist', TEST_BUCKET)
+    end
+  end
+  
+  # Regression test for http://developer.aliyunwebservices.com/connect/thread.jspa?messageID=49152&tstart=0#49152
+  def test_finding_an_object_with_slashes_in_its_name_does_not_escape_the_slash
+    OSSObject.store('rails/1', 'value does not matter', TEST_BUCKET)
+    OSSObject.store('rails/1.html', 'value does not matter', TEST_BUCKET)
+    
+    object = nil
+    assert_nothing_raised do
+      object = OSSObject.find('rails/1.html', TEST_BUCKET)
+    end
+    
+    assert_equal 'rails/1.html', object.key
+  ensure
+    %w(rails/1 rails/1.html).each {|key| OSSObject.delete(key, TEST_BUCKET)}
+  end
+  
+  def test_finding_an_object_with_spaces_in_its_name    
+    assert_nothing_raised do
+      OSSObject.store('name with spaces', 'value does not matter', TEST_BUCKET)
+    end
+    
+    object = nil
+    assert_nothing_raised do
+      object = OSSObject.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
+    OSSObject.delete('name with spaces', 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
+      OSSObject.store(key, 'value does not matter', TEST_BUCKET)
+    end
+    
+    object = nil
+    assert_nothing_raised do
+      object = OSSObject.find(key, TEST_BUCKET)
+    end
+
+    assert object
+    
+    url = nil
+    assert_nothing_raised do
+      url = OSSObject.url_for(key, TEST_BUCKET)
+    end
+    
+    assert url
+    
+    assert_equal object.value, fetch_object_at(url).body
+  ensure
+    assert_nothing_raised do
+      OSSObject.delete(key, TEST_BUCKET)
+    end
+  end
+  
+  private
+    def fetch_object_at(url)
+      Net::HTTP.get_response(URI.parse(url))
+    end
+    
+end