ryanking-aws-s3 0.5.1.200811101723

data/test/bucket_test.rb

@@ -0,0 +1,74 @@
+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,216 @@
+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'}
+  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://s3\.amazonaws\.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://s3\.amazonaws\.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['?AWSAccessKeyId']}
+    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
+  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.s3.amazonaws.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]
+      assert !options.instance_variable_get('@options').has_key?(key)
+    end
+      
+    def generate_options(options = {})
+      Connection::Options.new(options)
+    end
+end

data/test/error_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ErrorTest < Test::Unit::TestCase
+  def setup
+    @container = AWS::S3
+    @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

data/test/extensions_test.rb

@@ -0,0 +1,331 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class HashExtensionsTest < Test::Unit::TestCase
+  def test_to_query_string
+    # Because hashes aren't ordered, I'm mostly testing against hashes with just one key
+    symbol_keys = {:one => 1}
+    string_keys = {'one' => 1}
+    expected    = '?one=1'
+    [symbol_keys, string_keys].each do |hash|
+      assert_equal expected, hash.to_query_string
+    end
+  end
+  
+  def test_empty_hash_returns_no_query_string
+    assert_equal '', {}.to_query_string
+  end
+  
+  def test_include_question_mark
+    hash = {:one => 1}
+    assert_equal '?one=1', hash.to_query_string
+    assert_equal 'one=1', hash.to_query_string(false)
+  end
+  
+  def test_elements_joined_by_ampersand
+    hash = {:one => 1, :two => 2}
+    qs   = hash.to_query_string
+    assert qs['one=1&two=2'] || qs['two=2&one=1']
+  end
+  
+  def test_normalized_options
+    expectations = [
+      [{:foo_bar  => 1}, {'foo-bar' => '1'}],
+      [{'foo_bar' => 1}, {'foo-bar' => '1'}],
+      [{'foo-bar' => 1}, {'foo-bar' => '1'}],
+      [{}, {}]
+    ]
+    
+    expectations.each do |(before, after)|
+      assert_equal after, before.to_normalized_options
+    end
+  end
+end
+
+class StringExtensionsTest < Test::Unit::TestCase
+  def test_previous
+    expectations = {'abc' => 'abb', '123' => '122', '1' => '0'}
+    expectations.each do |before, after|
+      assert_equal after, before.previous
+    end
+  end
+  
+  def test_to_header
+    transformations = {
+      'foo'     => 'foo',
+      :foo      => 'foo',
+      'foo-bar' => 'foo-bar',
+      'foo_bar' => 'foo-bar',
+      :foo_bar  => 'foo-bar',
+      'Foo-Bar' => 'foo-bar',
+      'Foo_Bar' => 'foo-bar'
+    }
+    
+    transformations.each do |before, after|
+      assert_equal after, before.to_header
+    end
+  end
+  
+  def test_utf8?
+    assert !"318597/620065/GTL_75\24300_A600_A610.zip".utf8?
+    assert "318597/620065/GTL_75£00_A600_A610.zip".utf8?
+  end
+  
+  def test_remove_extended
+    assert "318597/620065/GTL_75\24300_A600_A610.zip".remove_extended.utf8?
+    assert "318597/620065/GTL_75£00_A600_A610.zip".remove_extended.utf8?
+  end
+end
+
+class CoercibleStringTest < Test::Unit::TestCase  
+  
+  def test_coerce
+    coercions = [
+      ['1', 1],
+      ['false', false],
+      ['true',  true],
+      ['2006-10-29T23:14:47.000Z', Time.parse('2006-10-29T23:14:47.000Z')],
+      ['Hello!', 'Hello!'],
+      ['false23', 'false23'],
+      ['03 1-2-3-Apple-Tree.mp3', '03 1-2-3-Apple-Tree.mp3'],
+      ['0815', '0815'] # This number isn't coerced because the leading zero would be lost
+    ]
+    
+    coercions.each do |before, after|
+      assert_nothing_raised do
+        assert_equal after, CoercibleString.coerce(before)
+      end
+    end
+  end
+end
+
+class KerneltExtensionsTest < Test::Unit::TestCase
+  class Foo
+    def foo
+      __method__
+    end
+
+    def bar
+      foo
+    end
+
+    def baz
+      bar
+    end
+  end
+  
+  class Bar
+    def foo
+      calling_method
+    end
+    
+    def bar
+      calling_method
+    end
+    
+    def calling_method
+      __method__(1)
+    end
+  end
+    
+  def test___method___works_regardless_of_nesting
+    f = Foo.new
+    [:foo, :bar, :baz].each do |method|
+      assert_equal 'foo', f.send(method)
+    end
+  end
+  
+  def test___method___depth
+    b = Bar.new
+    assert_equal 'foo', b.foo
+    assert_equal 'bar', b.bar
+  end
+end
+
+class ModuleExtensionsTest < Test::Unit::TestCase
+  class Foo
+    def foo(reload = false)
+      memoize(reload) do
+        Time.now
+      end
+    end
+    
+    def bar(reload = false)
+      memoize(reload, :baz) do
+        Time.now
+      end
+    end
+    
+    def quux
+      Time.now
+    end
+    memoized :quux
+  end
+  
+  def setup
+    @instance = Foo.new
+  end
+  
+  def test_memoize
+    assert !@instance.instance_variables.include?('@foo')
+    cached_result = @instance.foo
+    assert_equal cached_result, @instance.foo
+    assert @instance.instance_variables.include?('@foo')
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@foo)
+    assert_not_equal cached_result, new_cache = @instance.foo(:reload)
+    assert_equal new_cache, @instance.foo
+    assert_equal new_cache, @instance.send(:instance_variable_get, :@foo)
+  end
+  
+  def test_customizing_memoize_storage
+    assert !@instance.instance_variables.include?('@bar')
+    assert !@instance.instance_variables.include?('@baz')
+    cached_result = @instance.bar
+    assert !@instance.instance_variables.include?('@bar')
+    assert @instance.instance_variables.include?('@baz')
+    assert_equal cached_result, @instance.bar
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@baz)
+    assert_nil @instance.send(:instance_variable_get, :@bar)
+  end
+  
+  def test_memoized
+    assert !@instance.instance_variables.include?('@quux')
+    cached_result = @instance.quux
+    assert_equal cached_result, @instance.quux
+    assert @instance.instance_variables.include?('@quux')
+    assert_equal cached_result, @instance.send(:instance_variable_get, :@quux)
+    assert_not_equal cached_result, new_cache = @instance.quux(:reload)
+    assert_equal new_cache, @instance.quux
+    assert_equal new_cache, @instance.send(:instance_variable_get, :@quux)
+  end
+  
+  def test_constant_setting
+    some_module = Module.new
+    assert !some_module.const_defined?(:FOO)
+    assert_nothing_raised do
+      some_module.constant :FOO, 'bar'
+    end
+    
+    assert some_module.const_defined?(:FOO)
+    assert_nothing_raised do
+      some_module::FOO
+      some_module.foo
+    end
+    assert_equal 'bar', some_module::FOO
+    assert_equal 'bar', some_module.foo
+    
+    assert_nothing_raised do
+      some_module.constant :FOO, 'baz'
+    end
+    
+    assert_equal 'bar', some_module::FOO
+    assert_equal 'bar', some_module.foo
+  end
+end
+
+class AttributeProxyTest < Test::Unit::TestCase
+  class BlindProxyUsingDefaultAttributesHash
+    include SelectiveAttributeProxy
+    proxy_to :exlusively => false
+  end
+  
+  class BlindProxyUsingCustomAttributeHash
+    include SelectiveAttributeProxy
+    proxy_to :settings
+  end
+  
+  class ProxyUsingPassedInAttributeHash
+    include SelectiveAttributeProxy
+    
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+  end
+  
+  class RestrictedProxy
+    include SelectiveAttributeProxy
+    
+    private
+      def proxiable_attribute?(name)
+        %w(foo bar baz).include?(name)
+      end
+  end
+  
+  class NonExclusiveProxy
+    include SelectiveAttributeProxy
+    proxy_to :settings, :exclusively => false
+  end  
+  
+  def test_using_all_defaults
+    b = BlindProxyUsingDefaultAttributesHash.new
+    assert_nothing_raised do
+      b.foo = 'bar'
+    end
+    
+    assert_nothing_raised do
+      b.foo
+    end
+    
+    assert_equal 'bar', b.foo
+  end
+  
+  def test_storage_is_autovivified
+    b = BlindProxyUsingDefaultAttributesHash.new
+    assert_nothing_raised do
+      b.send(:attributes)['foo'] = 'bar'
+    end
+    
+    assert_nothing_raised do
+      b.foo
+    end
+    
+    assert_equal 'bar', b.foo
+  end
+  
+  def test_limiting_which_attributes_are_proxiable
+    r = RestrictedProxy.new
+    assert_nothing_raised do
+      r.foo = 'bar'
+    end
+    
+    assert_nothing_raised do
+      r.foo
+    end
+    
+    assert_equal 'bar', r.foo
+    
+    assert_raises(NoMethodError) do
+      r.quux = 'foo'
+    end
+    
+    assert_raises(NoMethodError) do
+      r.quux
+    end
+  end
+  
+  def test_proxying_is_exclusive_by_default
+    p = ProxyUsingPassedInAttributeHash.new('foo' => 'bar')
+    assert_nothing_raised do
+      p.foo
+      p.foo = 'baz'
+    end
+    
+    assert_equal 'baz', p.foo
+    
+    assert_raises(NoMethodError) do
+      p.quux
+    end
+  end
+  
+  def test_setting_the_proxy_as_non_exclusive
+    n = NonExclusiveProxy.new
+    assert_nothing_raised do
+      n.foo = 'baz'
+    end
+    
+    assert_nothing_raised do
+      n.foo
+    end
+    
+    assert_equal 'baz', n.foo
+  end
+end