aliyun-oss 0.7.0

data/test/base_test.rb

@@ -0,0 +1,137 @@
+# -*- encoding : utf-8 -*-
+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.oss.aliyuncs.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
+    
+    OSSObject.establish_connection!(:server => 'foo-bucket.oss.aliyuncs.com')
+    assert_nothing_raised do
+      assert_equal 'foo-bucket', OSSObject.current_bucket
+    end
+  end
+  
+  def test_setting_the_current_bucket
+    assert_equal 'foo', ClassToTestSettingCurrentBucket.current_bucket
+  end
+end

data/test/bucket_test.rb

@@ -0,0 +1,75 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+
+class BucketTest < Test::Unit::TestCase  
+  def test_bucket_name_validation
+    valid_names   = %w(123 joe step-one step_two step3 step_4 step-5 step.six)
+    invalid_names = ['12', 'jo', 'kevin spacey', 'larry@wall', '', 'a' * 256]
+    validate_name = Proc.new {|name| Bucket.send(:validate_name!, name)}
+    valid_names.each do |valid_name|
+      assert_nothing_raised { validate_name[valid_name] }
+    end
+    
+    invalid_names.each do |invalid_name|
+      assert_raises(InvalidBucketName) { validate_name[invalid_name] }
+    end
+  end
+  
+  def test_empty_bucket
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.empty_bucket, :code => 200})
+    bucket = Bucket.find('marcel_molina')
+    assert bucket.empty?
+  end
+  
+  def test_bucket_with_one_file
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key, :code => 200})
+    bucket = Bucket.find('marcel_molina')
+    assert !bucket.empty?
+    assert_equal 1, bucket.size
+    assert_equal %w(tongue_overload.jpg), bucket.objects.map {|object| object.key}
+    assert bucket['tongue_overload.jpg']
+  end
+  
+  def test_bucket_with_more_than_one_file
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_more_than_one_key, :code => 200})
+    bucket = Bucket.find('marcel_molina')
+    assert !bucket.empty?
+    assert_equal 2, bucket.size
+    assert_equal %w(beluga_baby.jpg tongue_overload.jpg), bucket.objects.map {|object| object.key}.sort
+    assert bucket['tongue_overload.jpg']
+  end
+  
+  def test_bucket_path
+    assert_equal '/bucket_name?max-keys=2', Bucket.send(:path, 'bucket_name', :max_keys => 2)
+    assert_equal '/bucket_name', Bucket.send(:path, 'bucket_name', {})    
+  end
+  
+  def test_should_not_be_truncated
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_more_than_one_key, :code => 200})
+    bucket = Bucket.find('marcel_molina')
+    assert !bucket.is_truncated
+  end
+  
+  def test_should_be_truncated
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.truncated_bucket_with_more_than_one_key, :code => 200})
+    bucket = Bucket.find('marcel_molina')
+    assert bucket.is_truncated    
+  end
+  
+  def test_bucket_name_should_have_leading_slash_prepended_only_once_when_forcing_a_delete
+    # References bug: http://rubyforge.org/tracker/index.php?func=detail&aid=19158&group_id=2409&atid=9356
+    bucket_name          = 'foo'
+    expected_bucket_path = "/#{bucket_name}"
+    
+    mock_bucket = flexmock('Mock bucket') do |mock|
+      mock.should_receive(:delete_all).once
+    end
+    mock_response = flexmock('Mock delete response') do |mock|
+      mock.should_receive(:success?).once
+    end
+    
+    flexmock(Bucket).should_receive(:find).with(bucket_name).once.and_return(mock_bucket)
+    flexmock(Base).should_receive(:delete).with(expected_bucket_path).once.and_return(mock_response)
+    Bucket.delete(bucket_name, :force => true)
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,218 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+  attr_reader :keys
+  def setup
+    @keys = {:access_key_id => '123', :secret_access_key => 'abc'}.freeze
+  end
+  
+  def test_creating_a_connection
+    connection = Connection.new(keys)
+    assert_kind_of Net::HTTP, connection.http
+  end
+  
+  def test_use_ssl_option_is_set_in_connection
+    connection = Connection.new(keys.merge(:use_ssl => true))
+    assert connection.http.use_ssl?
+  end
+  
+  def test_setting_port_to_443_implies_use_ssl
+    connection = Connection.new(keys.merge(:port => 443))
+    assert connection.http.use_ssl?
+  end
+  
+  def test_protocol
+    connection = Connection.new(keys)
+    assert_equal 'http://', connection.protocol
+    connection = Connection.new(keys.merge(:use_ssl => true))
+    assert_equal 'https://', connection.protocol
+  end
+  
+  def test_url_for_honors_use_ssl_option_if_it_is_false_even_if_connection_has_use_ssl_option_set
+    # References bug: http://rubyforge.org/tracker/index.php?func=detail&aid=17628&group_id=2409&atid=9356
+    connection = Connection.new(keys.merge(:use_ssl => true))
+    assert_match %r(^http://), connection.url_for('/pathdoesnotmatter', :authenticated => false, :use_ssl => false)
+  end
+  
+  def test_connection_is_not_persistent_by_default
+    connection = Connection.new(keys)
+    assert !connection.persistent?
+    
+    connection = Connection.new(keys.merge(:persistent => true))
+    assert connection.persistent?
+  end
+  
+  def test_server_and_port_are_passed_onto_connection
+    connection = Connection.new(keys)
+    options    = connection.instance_variable_get('@options')
+    assert_equal connection.http.address, options[:server]
+    assert_equal connection.http.port, options[:port]
+  end
+  
+  def test_not_including_required_access_keys_raises
+    assert_raises(MissingAccessKey) do
+      Connection.new
+    end
+    
+    assert_raises(MissingAccessKey) do
+      Connection.new(:access_key_id => '123')
+    end
+    
+    assert_nothing_raised do
+      Connection.new(keys)
+    end
+  end
+  
+  def test_access_keys_extracted
+    connection = Connection.new(keys)
+    assert_equal '123', connection.access_key_id
+    assert_equal 'abc', connection.secret_access_key
+  end
+  
+  def test_request_method_class_lookup
+    connection = Connection.new(keys)
+    expectations = {
+     :get  => Net::HTTP::Get, :post   => Net::HTTP::Post,
+     :put  => Net::HTTP::Put, :delete => Net::HTTP::Delete,
+     :head => Net::HTTP::Head
+    }
+    
+    expectations.each do |verb, klass|
+      assert_equal klass, connection.send(:request_method, verb)
+    end
+  end
+
+  def test_url_for_uses_default_protocol_server_and_port
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :port => 80)
+    assert_match %r(^http://oss\.aliyuncs\.com/foo\?), connection.url_for('/foo')
+
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :use_ssl => true, :port => 443)
+    assert_match %r(^https://oss\.aliyuncs\.com/foo\?), connection.url_for('/foo')
+  end
+
+  def test_url_for_remembers_custom_protocol_server_and_port
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :server => 'example.org', :port => 555, :use_ssl => true)
+    assert_match %r(^https://example\.org:555/foo\?), connection.url_for('/foo')
+  end
+
+  def test_url_for_with_and_without_authenticated_urls
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :server => 'example.org')
+    authenticated = lambda {|url| url['?OSSAccessKeyId']}
+    assert authenticated[connection.url_for('/foo')]
+    assert authenticated[connection.url_for('/foo', :authenticated => true)]
+    assert !authenticated[connection.url_for('/foo', :authenticated => false)]
+  end
+  
+  def test_connecting_through_a_proxy
+    connection = nil
+    assert_nothing_raised do
+      connection = Connection.new(keys.merge(:proxy => sample_proxy_settings))
+    end
+    assert connection.http.proxy?
+  end
+  
+  def test_request_only_escapes_the_path_the_first_time_it_runs_and_not_subsequent_times
+    connection     = Connection.new(@keys)
+    unescaped_path = 'path with spaces'
+    escaped_path   = 'path%20with%20spaces'
+    
+    flexmock(Connection).should_receive(:prepare_path).with(unescaped_path).once.and_return(escaped_path).ordered
+    flexmock(connection.http).should_receive(:request).and_raise(Errno::EPIPE).ordered
+    flexmock(connection.http).should_receive(:request).ordered
+    connection.request :put, unescaped_path
+  rescue Net::HTTPBadResponse
+    #TODO 阿里云tengine过滤非法请求返回为非标准Http响应
+  end
+  
+  def test_if_request_has_no_body_then_the_content_length_is_set_to_zero
+    # References bug: http://rubyforge.org/tracker/index.php?func=detail&aid=13052&group_id=2409&atid=9356
+    connection = Connection.new(@keys)
+    flexmock(Net::HTTP::Put).new_instances.should_receive(:content_length=).once.with(0).ordered
+    flexmock(connection.http).should_receive(:request).once.ordered
+    connection.request :put, 'path does not matter'
+  end
+end
+
+class ConnectionOptionsTest < Test::Unit::TestCase
+  
+  def setup
+    @options = generate_options(:server => 'example.org', :port => 555)
+    @default_options = generate_options
+  end
+  
+  def test_server_extracted
+    assert_key_transfered(:server, 'example.org', @options)
+  end
+  
+  def test_port_extracted
+    assert_key_transfered(:port, 555, @options)
+  end
+  
+  def test_server_defaults_to_default_host
+    assert_equal DEFAULT_HOST, @default_options[:server]
+  end
+  
+  def test_port_defaults_to_80_if_use_ssl_is_false
+    assert_equal 80, @default_options[:port]
+  end
+  
+  def test_port_is_set_to_443_if_use_ssl_is_true
+    options = generate_options(:use_ssl => true)
+    assert_equal 443, options[:port]
+  end
+  
+  def test_explicit_port_trumps_use_ssl
+    options = generate_options(:port => 555, :use_ssl => true)
+    assert_equal 555, options[:port]
+  end
+  
+  def test_invalid_options_raise
+    assert_raises(InvalidConnectionOption) do
+      generate_options(:host => 'campfire.oss.aliyuncs.com')
+    end
+  end
+  
+  def test_not_specifying_all_required_proxy_settings_raises
+    assert_raises(ArgumentError) do
+      generate_options(:proxy => {})
+    end
+  end
+  
+  def test_not_specifying_proxy_option_at_all_does_not_raise
+    assert_nothing_raised do
+      generate_options
+    end
+  end
+  
+  def test_specifying_all_required_proxy_settings
+    assert_nothing_raised do
+      generate_options(:proxy => sample_proxy_settings)
+    end
+  end
+  
+  def test_only_host_setting_is_required
+    assert_nothing_raised do
+      generate_options(:proxy => {:host => 'http://google.com'})
+    end
+  end
+  
+  def test_proxy_settings_are_extracted
+    options = generate_options(:proxy => sample_proxy_settings)
+    assert_equal sample_proxy_settings.values.map {|value| value.to_s}.sort, options.proxy_settings.map {|value| value.to_s}.sort
+  end
+  
+  def test_recognizing_that_the_settings_want_to_connect_through_a_proxy
+    options = generate_options(:proxy => sample_proxy_settings)
+    assert options.connecting_through_proxy?
+  end
+  
+  private
+    def assert_key_transfered(key, value, options)
+      assert_equal value, options[key]
+    end
+      
+    def generate_options(options = {})
+      Connection::Options.new(options)
+    end
+end

data/test/error_test.rb

@@ -0,0 +1,71 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/test_helper'
+
+class ErrorTest < Test::Unit::TestCase
+  def setup
+    @container = Aliyun::OSS
+    @error = Error.new(Parsing::XmlParser.new(Fixtures::Errors.access_denied))
+    @container.send(:remove_const, :NotImplemented) if @container.const_defined?(:NotImplemented)
+  end
+  
+  def test_error_class_is_automatically_generated
+    assert !@container.const_defined?('NotImplemented')
+    error = Error.new(Parsing::XmlParser.new(Fixtures::Errors.not_implemented))
+    assert @container.const_defined?('NotImplemented')
+  end
+  
+  def test_error_contains_attributes
+    assert_equal 'Access Denied', @error.message
+  end
+  
+  def test_error_is_raisable_as_exception
+    assert_raises(@container::AccessDenied) do
+      @error.raise
+    end
+  end
+  
+  def test_error_message_is_passed_along_to_exception    
+    @error.raise
+  rescue @container::AccessDenied => e
+    assert_equal 'Access Denied', e.message
+  end
+  
+  def test_response_is_passed_along_to_exception
+    response = Error::Response.new(FakeResponse.new(:code => 409, :body => Fixtures::Errors.access_denied))
+    response.error.raise
+  rescue @container::ResponseError => e
+    assert e.response
+    assert_kind_of Error::Response, e.response
+    assert_equal response.error, e.response.error
+  end
+  
+  def test_exception_class_clash
+    assert !@container.const_defined?(:NotImplemented)
+    # Create a class that does not inherit from exception that has the same name as the class
+    # the Error instance is about to attempt to find or create
+    @container.const_set(:NotImplemented, Class.new)
+    assert @container.const_defined?(:NotImplemented)
+    
+    assert_raises(ExceptionClassClash) do
+      Error.new(Parsing::XmlParser.new(Fixtures::Errors.not_implemented))
+    end
+  end
+  
+  def test_error_response_handles_attributes_with_no_value
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Errors.error_with_no_message, :code => 500})
+    
+    begin
+      Bucket.create('foo', 'invalid-argument' => 'bad juju')
+    rescue ResponseError => error
+    end
+  
+    assert_nothing_raised do
+      error.response.error.message
+    end
+    assert_nil error.response.error.message
+    
+    assert_raises(NoMethodError) do
+      error.response.error.non_existant_method
+    end
+  end
+end