alancse-aws-s3 0.4.1

data/test/authentication_test.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class HeaderAuthenticationTest < Test::Unit::TestCase  
+  def test_encoded_canonical
+    signature = Authentication::Signature.new(request, key_id, secret, current_host)
+    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, current_host)
+    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
+    def current_host; AmazonDocExampleData::Example1.current_host end
+end
+
+class QueryStringAuthenticationTest < Test::Unit::TestCase
+  def test_query_string
+    query_string = Authentication::QueryString.new(request, key_id, secret, current_host, :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, current_host, :expires => expires)
+    assert_equal expires, query_string.send(:canonical_string).instance_variable_get(:@options)[:expires]
+    assert_equal AmazonDocExampleData::Example3.query_string, query_string
+  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
+    def current_host; AmazonDocExampleData::Example3.current_host end
+end
+
+class CanonicalStringTest < Test::Unit::TestCase  
+  def setup
+    @request = Net::HTTP::Post.new('/test')
+    @current_host = 'quotes'
+    @canonical_string = Authentication::CanonicalString.new(@request, @current_host)
+  end
+  
+  def test_path_does_not_include_query_string
+    request = Net::HTTP::Get.new('/test/query/string?foo=bar&baz=quux')
+    assert_equal '/quotes/test/query/string', Authentication::CanonicalString.new(request, @current_host).send(:path)
+    
+    # Make sure things still work when there is *no* query string
+    request = Net::HTTP::Get.new('/')
+    assert_equal '/quotes/', Authentication::CanonicalString.new(request, @current_host).send(:path)
+    request = Net::HTTP::Get.new('/foo/bar')
+    assert_equal '/quotes/foo/bar', Authentication::CanonicalString.new(request, @current_host).send(:path)
+  end
+  
+  def test_path_includes_significant_query_strings
+    significant_query_strings = [
+      ['/test/query/string?acl',             '/quotes/test/query/string?acl'],
+      ['/test/query/string?acl&foo=bar',     '/quotes/test/query/string?acl'],
+      ['/test/query/string?foo=bar&acl',     '/quotes/test/query/string?acl'],
+      ['/test/query/string?acl=foo',         '/quotes/test/query/string?acl'],
+      ['/test/query/string?torrent=foo',     '/quotes/test/query/string?torrent'],
+      ['/test/query/string?logging=foo',     '/quotes/test/query/string?logging'],
+      ['/test/query/string?bar=baz&acl=foo', '/quotes/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), @current_host).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, @current_host)
+    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, @current_host)
+    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, @current_host)
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,143 @@
+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
+    Bucket.in_test_mode do
+      Bucket.request_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    
+  end
+  
+  def test_request_tries_up_to_three_times
+    Bucket.in_test_mode do
+      Bucket.request_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
+  end
+  
+  def test_request_tries_again_three_times_and_gives_up
+    Bucket.in_test_mode do
+      Bucket.request_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
+end
+
+class MultiConnectionsTest < Test::Unit::TestCase
+  class ClassToTestSettingCurrentBucket < Base
+    set_current_bucket_to 'foo'
+  end
+
+  def setup
+    Base.send(:connections).clear
+  end
+  alias_method :teardown, :setup
+  
+  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 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,48 @@
+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
+    Bucket.request_always_returns :body => Fixtures::Buckets.empty_bucket, :code => 200 do
+      bucket = Bucket.find('marcel_molina')
+      assert bucket.empty?
+    end
+  end
+  
+  def test_bucket_with_one_file
+    Bucket.request_always_returns :body => Fixtures::Buckets.bucket_with_one_key, :code => 200 do
+      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
+  end
+  
+  def test_bucket_with_more_than_one_file
+    Bucket.request_always_returns :body => Fixtures::Buckets.bucket_with_more_than_one_key, :code => 200 do
+      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
+  end
+  
+  def test_bucket_path
+    assert_equal '/?max-keys=2', Bucket.send(:path, 'bucket_name', :max_keys => 2)
+    assert_equal '/', Bucket.send(:path, 'bucket_name', {})    
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,190 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+  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_connection_is_persistent_by_default
+    connection = Connection.new(@keys)
+    assert connection.persistent?
+    
+    connection = Connection.new(@keys.merge(:persistent => false))
+    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
+    c = 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, c.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://mybucket\.s3\.amazonaws\.com/foo\?), connection.url_for('/foo', 'mybucket')
+
+    connection = Connection.new(:access_key_id => '123', :secret_access_key => 'abc', :use_ssl => true, :port => 443)
+    assert_match %r(^https://mybucket\.s3\.amazonaws\.com/foo\?), connection.url_for('/foo', 'mybucket')
+  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://mybucket\.example\.org:555/foo\?), connection.url_for('/foo', 'mybucket')
+  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', 'mybucket')]
+    assert authenticated[connection.url_for('/foo', 'mybucket', :authenticated => true)]
+    assert !authenticated[connection.url_for('/foo', 'mybucket', :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
+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