jaf-s3 0.6.3.1286550476

data/test/authentication_test.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class HeaderAuthenticationTest < Test::Unit::TestCase  
+  def test_encoded_canonical
+    signature = Authentication::Signature.new(request, key_id, secret)
+    assert_equal AmazonDocExampleData::Example1.canonical_string, signature.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example1.signature, signature.send(:encoded_canonical)
+  end
+  
+  def test_authorization_header
+    header = Authentication::Header.new(request, key_id, secret)
+    assert_equal AmazonDocExampleData::Example1.canonical_string, header.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example1.authorization_header, header
+  end
+  
+  private
+    def request; AmazonDocExampleData::Example1.request end
+    def key_id ; AmazonDocExampleData::Example1.access_key_id end
+    def secret ; AmazonDocExampleData::Example1.secret_access_key end
+end
+
+class QueryStringAuthenticationTest < Test::Unit::TestCase
+  def test_query_string
+    query_string = Authentication::QueryString.new(request, key_id, secret, :expires_in => 60)
+    assert_equal AmazonDocExampleData::Example3.canonical_string, query_string.send(:canonical_string)
+    assert_equal AmazonDocExampleData::Example3.query_string, query_string
+  end
+  
+  def test_query_string_with_explicit_expiry
+    query_string = Authentication::QueryString.new(request, key_id, secret, :expires => expires)
+    assert_equal expires, query_string.send(:canonical_string).instance_variable_get(:@options)[:expires]
+    assert_equal AmazonDocExampleData::Example3.query_string, query_string
+  end
+  
+  def test_expires_in_is_coerced_to_being_an_integer_in_case_it_is_a_special_integer_proxy
+    # References bug: http://rubyforge.org/tracker/index.php?func=detail&aid=17458&group_id=2409&atid=9356
+    integer_proxy = Class.new do
+      attr_reader :integer
+      def initialize(integer)
+        @integer = integer
+      end
+      
+      def to_int
+        integer
+      end
+    end
+    
+    actual_integer = 25
+    query_string = Authentication::QueryString.new(request, key_id, secret, :expires_in => integer_proxy.new(actual_integer))
+    assert_equal actual_integer, query_string.send(:expires_in)
+  end
+  
+  private
+    def request; AmazonDocExampleData::Example3.request end
+    def key_id ; AmazonDocExampleData::Example3.access_key_id end
+    def secret ; AmazonDocExampleData::Example3.secret_access_key end
+    def expires; AmazonDocExampleData::Example3.expires end
+end
+
+class CanonicalStringTest < Test::Unit::TestCase  
+  def setup
+    @request = Net::HTTP::Post.new('/test')
+    @canonical_string = Authentication::CanonicalString.new(@request)
+  end
+  
+  def test_path_does_not_include_query_string
+    request = Net::HTTP::Get.new('/test/query/string?foo=bar&baz=quux')
+    assert_equal '/test/query/string', Authentication::CanonicalString.new(request).send(:path)
+    
+    # Make sure things still work when there is *no* query string
+    request = Net::HTTP::Get.new('/')
+    assert_equal '/', Authentication::CanonicalString.new(request).send(:path)
+    request = Net::HTTP::Get.new('/foo/bar')
+    assert_equal '/foo/bar', Authentication::CanonicalString.new(request).send(:path)
+  end
+  
+  def test_path_includes_significant_query_strings
+    significant_query_strings = [
+      ['/test/query/string?acl',             '/test/query/string?acl'],
+      ['/test/query/string?acl&foo=bar',     '/test/query/string?acl'],
+      ['/test/query/string?foo=bar&acl',     '/test/query/string?acl'],
+      ['/test/query/string?acl=foo',         '/test/query/string?acl'],
+      ['/test/query/string?torrent=foo',     '/test/query/string?torrent'],
+      ['/test/query/string?logging=foo',     '/test/query/string?logging'],
+      ['/test/query/string?bar=baz&acl=foo', '/test/query/string?acl']
+    ]
+    
+    significant_query_strings.each do |uncleaned_path, expected_cleaned_path|
+      assert_equal expected_cleaned_path, Authentication::CanonicalString.new(Net::HTTP::Get.new(uncleaned_path)).send(:path)
+    end
+  end
+  
+  def test_default_headers_set
+    Authentication::CanonicalString.default_headers.each do |header|
+      assert @canonical_string.headers.include?(header)
+    end
+  end
+  
+  def test_interesting_headers_are_copied_over
+    an_interesting_header = 'content-md5'
+    string_without_interesting_header = Authentication::CanonicalString.new(@request)
+    assert string_without_interesting_header.headers[an_interesting_header].empty?
+    
+    # Add an interesting header
+    @request[an_interesting_header] = 'foo'
+    string_with_interesting_header = Authentication::CanonicalString.new(@request)
+    assert_equal 'foo', string_with_interesting_header.headers[an_interesting_header]
+  end
+  
+  def test_canonical_string
+    request = AmazonDocExampleData::Example1.request
+    assert_equal AmazonDocExampleData::Example1.canonical_string, Authentication::CanonicalString.new(request)
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,136 @@
+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.s3.amazonaws.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
+    
+    S3Object.establish_connection!(:server => 'foo-bucket.s3.amazonaws.com')
+    assert_nothing_raised do
+      assert_equal 'foo-bucket', S3Object.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,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,215 @@
+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://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]
+    end
+      
+    def generate_options(options = {})
+      Connection::Options.new(options)
+    end
+end