aws-s3 0.4.0 → 0.5.0

data/test/bucket_test.rb

@@ -15,34 +15,60 @@ class BucketTest < Test::Unit::TestCase
   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
+    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
-    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
+    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
-    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
+    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

@@ -1,42 +1,49 @@
 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)
+    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))
+    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))
+    connection = Connection.new(keys.merge(:port => 443))
     assert connection.http.use_ssl?
   end
   
   def test_protocol
-    connection = Connection.new(@keys)
+    connection = Connection.new(keys)
     assert_equal 'http://', connection.protocol
-    connection = Connection.new(@keys.merge(:use_ssl => true))
+    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))
+  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)
+    connection = Connection.new(keys)
     options    = connection.instance_variable_get('@options')
     assert_equal connection.http.address, options[:server]
     assert_equal connection.http.port, options[:port]
@@ -52,18 +59,18 @@ class ConnectionTest < Test::Unit::TestCase
     end
     
     assert_nothing_raised do
-      Connection.new(@keys)
+      Connection.new(keys)
     end
   end
   
   def test_access_keys_extracted
-    connection = Connection.new(@keys)
+    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)
+    connection = Connection.new(keys)
     expectations = {
      :get  => Net::HTTP::Get, :post   => Net::HTTP::Post,
      :put  => Net::HTTP::Put, :delete => Net::HTTP::Delete,
@@ -71,7 +78,7 @@ class ConnectionTest < Test::Unit::TestCase
     }
     
     expectations.each do |verb, klass|
-      assert_equal klass, c.send(:request_method, verb)
+      assert_equal klass, connection.send(:request_method, verb)
     end
   end
 
@@ -99,10 +106,29 @@ class ConnectionTest < Test::Unit::TestCase
   def test_connecting_through_a_proxy
     connection = nil
     assert_nothing_raised do
-      connection = Connection.new(@keys.merge(:proxy => sample_proxy_settings))
+      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

data/test/error_test.rb

@@ -4,9 +4,6 @@ class ErrorTest < Test::Unit::TestCase
   def setup
     @container = AWS::S3
     @error = Error.new(Parsing::XmlParser.new(Fixtures::Errors.access_denied))
-  end
-  
-  def teardown
     @container.send(:remove_const, :NotImplemented) if @container.const_defined?(:NotImplemented)
   end
   
@@ -54,22 +51,20 @@ class ErrorTest < Test::Unit::TestCase
   end
   
   def test_error_response_handles_attributes_with_no_value
-    Bucket.in_test_mode do
-      Bucket.request_returns :body => Fixtures::Errors.error_with_no_message, :code => 500
-      
-      begin
-        Bucket.create('foo', 'invalid-argument' => 'bad juju')
-      rescue ResponseError => error
-      end
+    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_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
+    assert_raises(NoMethodError) do
+      error.response.error.non_existant_method
     end
   end
 end

data/test/fixtures/buckets.yml

@@ -100,3 +100,34 @@ bucket_with_more_than_one_key: >
       <StorageClass>STANDARD</StorageClass>
     </Contents>
   </ListBucketResult>
+  
+truncated_bucket_with_more_than_one_key: >
+  <ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+    <Name>marcel_molina</Name>
+    <Prefix></Prefix>
+    <Marker></Marker>
+    <MaxKeys>2</MaxKeys>
+    <IsTruncated>true</IsTruncated>
+    <Contents>
+      <Key>beluga_baby.jpg</Key>
+      <LastModified>2006-10-05T02:55:10.000Z</LastModified>
+      <ETag>&quot;b2453d4a39a7387674a8c505112a2f0b&quot;</ETag>
+      <Size>35807</Size>
+      <Owner>
+        <ID>bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1</ID>
+        <DisplayName>mmolina@onramp.net</DisplayName>
+      </Owner>
+      <StorageClass>STANDARD</StorageClass>
+    </Contents>
+    <Contents>
+      <Key>tongue_overload.jpg</Key>
+      <LastModified>2006-10-05T02:42:22.000Z</LastModified>
+      <ETag>&quot;f21f7c4e8ea6e34b268887b07d6da745&quot;</ETag>
+      <Size>60673</Size>
+      <Owner>
+        <ID>bb2041a25975c3d4ce9775fe9e93e5b77a6a9fad97dc7e00686191f3790b13f1</ID>
+        <DisplayName>mmolina@onramp.net</DisplayName>
+      </Owner>
+      <StorageClass>STANDARD</StorageClass>
+    </Contents>
+  </ListBucketResult>

data/test/mocks/fake_response.rb

@@ -0,0 +1,26 @@
+module AWS
+  module S3
+    class FakeResponse
+      attr_reader :code, :body, :headers
+      def initialize(options = {})
+        @code    = options.delete(:code)  || 200 
+        @body    = options.delete(:body)  || ''
+        @headers = {'content-type' => 'application/xml'}.merge(options.delete(:headers) || {})
+      end
+
+      # For ErrorResponse
+      def response
+        body
+      end
+      
+      def [](header)
+        headers[header]
+      end
+      
+      def each(&block)
+        headers.each(&block)
+      end
+      alias_method :each_header, :each
+    end
+  end
+end

data/test/object_test.rb

@@ -7,25 +7,23 @@ class ObjectTest < Test::Unit::TestCase
   end
   
   def test_header_settings_reader_and_writer
-    S3Object.in_test_mode do
-      headers = {'content-type' => 'text/plain'}
-      S3Object.request_returns :headers => headers
-      
-      assert_nothing_raised do
-        @object.content_type
-      end
+    headers = {'content-type' => 'text/plain'}
+    mock_connection_for(S3Object, :returns => {:headers => headers})
     
-      assert_equal 'text/plain', @object.content_type
-    
-      assert_nothing_raised do
-        @object.content_type = 'image/jpg'
-      end
-    
-      assert_equal 'image/jpg', @object.content_type
-    
-      assert_raises(NoMethodError) do
-        @object.non_existant_header_setting
-      end
+    assert_nothing_raised do
+      @object.content_type
+    end
+  
+    assert_equal 'text/plain', @object.content_type
+  
+    assert_nothing_raised do
+      @object.content_type = 'image/jpg'
+    end
+  
+    assert_equal 'image/jpg', @object.content_type
+  
+    assert_raises(NoMethodError) do
+      @object.non_existant_header_setting
     end
   end
   
@@ -75,91 +73,81 @@ class ObjectTest < Test::Unit::TestCase
   end
   
   def test_fetching_object_value_generates_value_object
-    S3Object.in_test_mode do
-      S3Object.request_returns :body => 'hello!'
-      value = S3Object.value('foo', 'bar')
-      assert_kind_of S3Object::Value, value
-      assert_equal 'hello!', value
-    end
+    mock_connection_for(S3Object, :returns => {:body => 'hello!'})
+    value = S3Object.value('foo', 'bar')
+    assert_kind_of S3Object::Value, value
+    assert_equal 'hello!', value
   end
   
   def test_fetching_file_by_name_raises_when_heuristic_fails
-    S3Object.request_always_returns :body => Fixtures::Buckets.bucket_with_one_key do
-      assert_raises(NoSuchKey) do
-        S3Object.find('not_tongue_overload.jpg', 'marcel_molina')
-      end
-      
-      object = nil # Block scoping
-      assert_nothing_raised do
-        object = S3Object.find('tongue_overload.jpg', 'marcel_molina')
-      end
-      assert_kind_of S3Object, object
-      assert_equal 'tongue_overload.jpg', object.key
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
+    assert_raises(NoSuchKey) do
+      S3Object.find('not_tongue_overload.jpg', 'marcel_molina')
     end
+    
+    object = nil # Block scoping
+    assert_nothing_raised do
+      object = S3Object.find('tongue_overload.jpg', 'marcel_molina')
+    end
+    assert_kind_of S3Object, object
+    assert_equal 'tongue_overload.jpg', object.key
   end
   
   def test_about
-    S3Object.in_test_mode do
-      headers = {'content-size' => '12345', 'date' => Time.now.httpdate, 'content-type' => 'application/xml'}
-      S3Object.request_returns :headers => headers
-      about = S3Object.about('foo', 'bar')
-      assert_kind_of S3Object::About, about
-      assert_equal headers, about
-      
-      S3Object.request_returns :code => 404
-      assert_raises(NoSuchKey) do
-        S3Object.about('foo', 'bar')
-      end
+    headers = {'content-size' => '12345', 'date' => Time.now.httpdate, 'content-type' => 'application/xml'}
+    mock_connection_for(S3Object, :returns => [
+      {:headers => headers},
+      {:code    => 404}
+      ]
+    )
+    about = S3Object.about('foo', 'bar')
+    assert_kind_of S3Object::About, about
+    assert_equal headers, about
+    
+    assert_raises(NoSuchKey) do
+      S3Object.about('foo', 'bar')
     end
   end
   
-  def test_exists?
-    S3Object.in_test_mode do
-      S3Object.request_returns :code => 404
-      assert_equal false, S3Object.exists?('foo', 'bar')
-      
-      S3Object.request_returns :code => 200
-      assert_equal true, S3Object.exists?('foo', 'bar')
-    end
+  def test_can_tell_that_an_s3object_does_not_exist
+    mock_connection_for(S3Object, :returns => {:code => 404})
+    assert_equal false, S3Object.exists?('foo', 'bar')
+  end
+  
+  def test_can_tell_that_an_s3object_exists
+    mock_connection_for(S3Object, :returns => {:code => 200})
+    assert_equal true, S3Object.exists?('foo', 'bar')
   end
   
   def test_s3object_equality
-    Bucket.in_test_mode do
-      Bucket.request_returns :body => Fixtures::Buckets.bucket_with_more_than_one_key
-      file1, file2 = Bucket.objects('does not matter')
-      assert file1 == file1
-      assert file2 == file2
-      assert !(file1 == file2) # /!\ Parens required /!\
-    end
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_more_than_one_key})
+    file1, file2 = Bucket.objects('does not matter')
+    assert file1 == file1
+    assert file2 == file2
+    assert !(file1 == file2) # /!\ Parens required /!\
   end
   
   def test_inspect
-    S3Object.in_test_mode do
-      S3Object.request_returns :body => Fixtures::Buckets.bucket_with_one_key
-      object = S3Object.find('tongue_overload.jpg', 'bucket does not matter')
-      assert object.path
-      assert_nothing_raised { object.inspect }
-      assert object.inspect[object.path]
-   end
- end
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
+    object = S3Object.find('tongue_overload.jpg', 'bucket does not matter')
+    assert object.path
+    assert_nothing_raised { object.inspect }
+    assert object.inspect[object.path]
+  end
  
- def test_etag
-  S3Object.in_test_mode do
-    S3Object.request_returns :body => Fixtures::Buckets.bucket_with_one_key
+  def test_etag
+    mock_connection_for(Bucket, :returns => {:body => Fixtures::Buckets.bucket_with_one_key})
     file = S3Object.find('tongue_overload.jpg', 'bucket does not matter')
     assert file.etag
     assert_equal 'f21f7c4e8ea6e34b268887b07d6da745', file.etag
   end
- end
  
- def test_fetching_information_about_an_object_that_does_not_exist_raises_no_such_key
-   S3Object.in_test_mode do
-     S3Object.request_returns :body => '', :code => 404
-     assert_raises(NoSuchKey) do
-       S3Object.about('asdfasdfasdfas-this-does-not-exist', 'bucket does not matter')
-     end
-   end
- end
+  def test_fetching_information_about_an_object_that_does_not_exist_raises_no_such_key
+    mock_connection_for(S3Object, :returns => {:body => '', :code => 404})
+    assert_raises(NoSuchKey) do
+      S3Object.about('asdfasdfasdfas-this-does-not-exist', 'bucket does not matter')
+    end
+  end
 end
 
 class MetadataTest < Test::Unit::TestCase