happening 0.2.0 → 0.2.1

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+Changelog
+=============
+
+0.2.1
+
+- Return the response object on get so that the data can be streamed [carlism]
+
+0.2.0
+
+- Initial release

data/README.md

@@ -139,6 +139,20 @@ You can also just load the headers of an S3 item:
     end
 
 
+    
+Streaming
+=============
+
+The response data can also be streamed:    
+  
+    EM.run do
+      item = Happening::S3::Item.new( bucket...
+	  item.get(:on_error => on_error, :on_success => on_success ).stream do |chunk|
+	    # .. handle the individual chunk          
+	  end
+    end
+    
+
 SSL Support
 =============
 

data/lib/happening/s3/request.rb

@@ -33,7 +33,7 @@ module Happening
 
         @response.errback { error_callback }
         @response.callback { success_callback }
-        nil
+        @response
       end
       
       def http_class

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: happening
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
+  hash: 21
+  prerelease: 
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Jonathan Weiss
@@ -15,13 +15,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-20 00:00:00 +02:00
-default_executable: 
+date: 2011-08-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: em-http-request
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -30,12 +27,26 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  name: happening
+  prerelease: false
   type: :runtime
-  version_requirements: *id001
+  requirement: *id001
 - !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   name: jeweler
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -44,12 +55,26 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  name: shoulda
+  prerelease: false
   type: :development
-  version_requirements: *id002
+  requirement: *id003
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: mocha
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  type: :development
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -58,12 +83,40 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  name: em-http-request
+  prerelease: false
+  type: :runtime
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: jeweler
+  prerelease: false
   type: :development
-  version_requirements: *id003
+  requirement: *id006
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: shoulda
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  type: :development
+  requirement: *id007
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -72,8 +125,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  name: mocha
+  prerelease: false
   type: :development
-  version_requirements: *id004
+  requirement: *id008
 description: An EventMachine based S3 client - using em-http-request
 email: info@peritor.com
 executables: []
@@ -84,6 +139,7 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files: 
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - lib/happening.rb
@@ -93,18 +149,12 @@ files:
 - lib/happening/s3/item.rb
 - lib/happening/s3/request.rb
 - lib/happening/utils.rb
-- test/aws_test.rb
-- test/s3/item_test.rb
-- test/s3/request_test.rb
-- test/s3_test.rb
-- test/test_helper.rb
-has_rdoc: true
 homepage: http://github.com/peritor/happening
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -128,13 +178,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: An EventMachine based S3 client
-test_files: 
-- test/aws_test.rb
-- test/s3/item_test.rb
-- test/s3/request_test.rb
-- test/s3_test.rb
-- test/test_helper.rb
+test_files: []
+

data/test/aws_test.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ItemTest < Test::Unit::TestCase
-  context "An Happening::AWS instance" do
-    
-    setup do
-      @aws = Happening::AWS.new('the-aws-access-key', 'the-aws-secret-key')
-    end
-    
-    context "when constructing" do
-      should "require Access Key and Secret Key" do
-        assert_raise(ArgumentError) do
-          Happening::AWS.new(nil, nil)
-        end
-        
-        assert_raise(ArgumentError) do
-          Happening::AWS.new('', '')
-        end
-        
-        assert_nothing_raised do
-          Happening::AWS.new('abc', 'abc')
-        end
-      end
-    end
-    
-    context "when signing parameters" do
-      should "return a header hash" do
-        assert_not_nil @aws.sign("GET", '/')['Authorization']
-      end
-      
-      should "include the current date" do
-        assert_not_nil @aws.sign("GET", '/')['date']
-      end
-      
-      should "keep given headers" do
-        assert_equal 'bar', @aws.sign("GET", '/', {'foo' => 'bar'})['foo']
-      end
-    end
-    
-  end
-end

data/test/s3/item_test.rb

@@ -1,507 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-class ItemTest < Test::Unit::TestCase
-  context "An Happening::S3::Item instance" do
-    
-    setup do
-      Happening::Log.level = Logger::ERROR
-      @item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :server => '127.0.0.1')
-      
-      @time = "Thu, 25 Feb 2010 10:00:00 GMT"
-      Time.stubs(:now).returns(Time.parse(@time))
-      #stub(:utc_httpdate => @time, :to_i => 99, :usec => 88))
-    end
-    
-    context "validation" do
-      should "require a bucket and a key" do
-        assert_raise(ArgumentError) do
-          item = Happening::S3::Item.new()
-        end
-        
-        assert_raise(ArgumentError) do
-          item = Happening::S3::Item.new('the-key')
-        end
-        
-        assert_nothing_raised(ArgumentError) do
-          item = Happening::S3::Item.new('the-bucket', 'the-key')
-        end
-        
-      end
-      
-      should "not allow unknown options" do
-        assert_raise(ArgumentError) do
-          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :lala => 'lulul')
-        end
-      end
-      
-      should "check valid protocol" do
-        assert_raise(ArgumentError) do
-          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'lulul')
-        end
-        
-        assert_nothing_raised do
-          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'http')
-        end
-        
-        assert_nothing_raised do
-          item = Happening::S3::Item.new('the-bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :protocol => 'https')
-        end
-      end
-    end
-    
-    context "when building the item url" do
-      should "build the full path out of the server, bucket, and key" do
-        @item = Happening::S3::Item.new('the-bucketissoooooooooooooooooooooooooooooooooooooolonggggggggggggggggggggggggggggggggggg', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret', :server => '127.0.0.1')
-        assert_equal "https://127.0.0.1:443/the-bucketissoooooooooooooooooooooooooooooooooooooolonggggggggggggggggggggggggggggggggggg/the-key", @item.url
-      end
-      
-      should "use the DNS bucket name where possible" do
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => '123', :aws_secret_access_key => 'secret')
-        assert_equal "https://bucket.s3.amazonaws.com:443/the-key", @item.url
-      end
-    end
-    
-    context "when getting an item" do
-      
-      should "call the on success callback" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, fake_response("data-here"))
-        
-        called = false
-        data = nil
-        on_success = Proc.new {|http| called = true, data = http.response}
-        @item = Happening::S3::Item.new('bucket', 'the-key')
-        run_in_em_loop do
-          @item.get(:on_success => on_success)
-          
-          EM.add_timer(1) {
-            assert called
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
-            assert_equal "data-here\n", data
-            EM.stop_event_loop
-          }
-          
-        end
-      end
-      
-      should "support direct blocks" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, fake_response("data-here"))
-        
-        called = false
-        data = nil
-        @item = Happening::S3::Item.new('bucket', 'the-key')
-        run_in_em_loop do
-          @item.get do |http| 
-            called = true
-            data = http.response
-          end
-          
-          EM.add_timer(1) {
-            assert called
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
-            assert_equal "data-here\n", data
-            EM.stop_event_loop
-          }
-          
-        end
-      end
-
-      should "sign requests if AWS credentials are passend" do
-        time = "Thu, 25 Feb 2010 12:06:33 GMT"
-        Time.stubs(:now).returns(Time.parse(time))
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {"Authorization"=>"AWS abc:3OEcVbE//maUUmqh3A5ETEcr9TE=", 'date' => time}, fake_response("data-here"))
-        
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.get
-          
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {"Authorization"=>"AWS abc:3OEcVbE//maUUmqh3A5ETEcr9TE=", 'date' => time})
-          }
-          
-        end
-      end
-      
-      should "retry on error" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, error_response(400))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key')
-        run_in_em_loop do
-          @item.get(:on_error => Proc.new{} ) #ignore error
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
-          }
-
-        end
-      end
-      
-      should "handle re-direct" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :get, {}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
-        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :get, {}, fake_response('hy there'))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key')
-        run_in_em_loop do
-          @item.get
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :get, {})
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :get, {})
-          }
-
-        end
-      end
-    end
-    
-    context "when deleting an item" do
-      should "send a DELETE to the items location" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, fake_response("data-here"))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.delete
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-      should "support direct blocks" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, fake_response("data-here"))
-        
-        called = false
-        data = nil
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.delete do |http| 
-            called = true
-            data = http.response
-          end
-          
-          EM.add_timer(1) {
-            assert called
-            assert_equal "data-here\n", data
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-          
-        end
-      end
-      
-      should "handle re-direct" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
-        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :delete, {
-           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, fake_response("success!"))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.delete
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :delete, {
-              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-      should "handle retry" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-           "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, error_response(400))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.delete(:on_error => Proc.new{} ) #ignore error
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :delete, {
-              "Authorization"=>"AWS abc:nvkrlq4wor1qbFXZh6rHnAbiRjk=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-    end
-
-    context "when loading the headers" do
-      should "request via HEAD" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :head, {}, fake_response('hy there'))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key')
-        run_in_em_loop do
-          @item.head
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :head, {})
-          }
-
-        end
-      end
-    end
-
-    context "when saving an item" do
-      
-      should "post to the desired location" do
-       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-         'date' => @time, 
-         'url' => "/bucket/the-key"}, fake_response("data-here"))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.put('content')
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-      should "support direct blocks" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-           "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-           'date' => @time, 
-           'url' => "/bucket/the-key"}, fake_response("data-here"))
-        
-        called = false
-        data = nil
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.put('upload me') do |http| 
-            called = true
-            data = http.response
-          end
-          
-          EM.add_timer(1) {
-            assert called
-            assert_equal "data-here\n", data
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-          
-        end
-      end
-      
-      should "set the desired permissions" do
-       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-         "Authorization"=>"AWS abc:cqkfX+nC7WIkYD+yWaUFuoRuePA=", 
-         'date' => @time, 
-         'url' => "/bucket/the-key",
-         "x-amz-acl" => 'public-read'}, fake_response("data-here"))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123' , :permissions => 'public-read')
-        run_in_em_loop do
-          @item.put('content')
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:cqkfX+nC7WIkYD+yWaUFuoRuePA=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key",
-              'x-amz-acl' => 'public-read'})
-          }
-
-        end
-      end
-      
-      should "allow to set custom headers" do
-       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-         "Authorization"=>"AWS abc:wrPkGKrlwH2AtNzBVS80vU73TDc=", 
-         'date' => @time, 
-         'url' => "/bucket/the-key",
-         "x-amz-acl" => 'public-read',
-         'Cache-Control' => "max-age=252460800",
-         'Expires' => 'Fri, 16 Nov 2018 22:09:29 GMT',
-         'x-amz-meta-abc' => 'ABC'}, fake_response("data-here"))
-         
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', 
-                                                             :aws_secret_access_key => '123' , 
-                                                             :permissions => 'public-read')
-        run_in_em_loop do
-          @item.put('content', :headers => { 
-             'Expires' => 'Fri, 16 Nov 2018 22:09:29 GMT',
-             'Cache-Control' => "max-age=252460800",
-             'x-amz-meta-abc' => 'ABC'})
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:wrPkGKrlwH2AtNzBVS80vU73TDc=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key",
-              'x-amz-acl' => 'public-read',
-              'Cache-Control' => "max-age=252460800",
-              'Expires' => 'Fri, 16 Nov 2018 22:09:29 GMT',
-              'x-amz-meta-abc' => 'ABC'})
-          }
-
-        end
-      end
-      
-      should "validate the headers" do
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', 
-                                                             :aws_secret_access_key => '123' , 
-                                                             :permissions => 'public-read')
-                                                             
-        assert_raise(ArgumentError) do
-          @item.put('content', :headers => { 
-             'expires' => 'Fri, 16 Nov 2018 22:09:29 GMT',
-             'cache_control' => "max-age=252460800"})
-        end                                                    
-      end
-      
-      should "re-post to a new location" do
-        EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-          "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-          'date' => @time, 
-          'url' => "/bucket/the-key"}, redirect_response('https://bucket.s3-external-3.amazonaws.com/the-key'))
-        EventMachine::MockHttpRequest.register('https://bucket.s3-external-3.amazonaws.com:443/the-key', :put, {
-          "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-          'date' => @time, 
-          'url' => "/bucket/the-key"}, fake_response('Thanks!')) 
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.put('content')
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-            
-            assert_equal 1, EventMachine::MockHttpRequest.count('https://bucket.s3-external-3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time, 
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-      should "retry on error" do
-       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-         'date' => @time, 
-         'url' => "/bucket/the-key"}, error_response(400))
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.put('content', :on_error => Proc.new{} )
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert_equal 5, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time,
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-      should "call error handler after retry reached" do
-       EventMachine::MockHttpRequest.register('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-         "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-         'date' => @time, 
-         'url' => "/bucket/the-key"}, error_response(400))
-
-       called = false
-       on_error = Proc.new {|http| called = true}
-
-        @item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        run_in_em_loop do
-          @item.put('content', :on_error => on_error, :retry_count => 1)
-
-          EM.add_timer(1) {
-            EM.stop_event_loop
-            assert called
-            assert_equal 2, EventMachine::MockHttpRequest.count('https://bucket.s3.amazonaws.com:443/the-key', :put, {
-              "Authorization"=>"AWS abc:lZMKxGDKcQ1PH8yjbpyN7o2sPWg=", 
-              'date' => @time,
-              'url' => "/bucket/the-key"})
-          }
-
-        end
-      end
-      
-    end
-    
-    context "SSL options" do
-      setup do
-        Happening::S3.ssl_options[:verify_peer] = true
-        Happening::S3.ssl_options[:cert_chain_file] = '/etc/foo.ca'
-      end
-      
-      should "re-use the global options" do
-        item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        assert item.options[:ssl][:verify_peer]
-        assert_equal '/etc/foo.ca', item.options[:ssl][:cert_chain_file]
-      end
-      
-      should "allow to override global options" do
-        item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123', :ssl => {:cert_chain_file => nil, :verify_peer => false})
-        assert !item.options[:ssl][:verify_peer]
-        assert_nil item.options[:ssl][:cert_chain_file]
-      end
-      
-      should "pass the options to the Request" do
-        item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        Happening::S3::Request.expects(:new).with(:get, anything, {:ssl => {:cert_chain_file => '/etc/foo.ca', :verify_peer => true}, :headers => {'Authorization' => 'AWS abc:LGLdCdGTuLAHs+InbMWEnQR6djc=', 'date' => 'Thu, 25 Feb 2010 10:00:00 GMT'}}).returns(stub(:execute => nil))
-        item.get
-      end
-      
-      should "allow to override the options per request" do
-        item = Happening::S3::Item.new('bucket', 'the-key', :aws_access_key_id => 'abc', :aws_secret_access_key => '123')
-        Happening::S3::Request.expects(:new).with(:get, anything, {:ssl => {:foo => :bar}, :headers => {'Authorization' => 'AWS abc:LGLdCdGTuLAHs+InbMWEnQR6djc=', 'date' => 'Thu, 25 Feb 2010 10:00:00 GMT'}}).returns(stub(:execute => nil))
-        item.get(:ssl => {:foo => :bar})
-      end
-    end
-    
-  end
-end

data/test/s3/request_test.rb

@@ -1,102 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-class ItemTest < Test::Unit::TestCase
-  context "An Happening::S3::Request instance" do
-    
-    setup do
-      Happening::Log.level = Logger::ERROR
-      @response_stub = stub()
-      @response_stub.stubs(:errback)
-      @response_stub.stubs(:callback)
-    end
-    
-    context "validation" do
-      should "check HTTP method" do
-        assert_raise(ArgumentError) do
-          Happening::S3::Request.new(:foo, 'https://www.example.com')
-        end
-        
-        assert_nothing_raised do
-          Happening::S3::Request.new(:get, 'https://www.example.com')
-        end
-      end
-      
-      should "check the options" do
-        assert_raise(ArgumentError) do
-          Happening::S3::Request.new(:get, 'https://www.example.com', {:foo => :bar})
-        end
-        
-        assert_nothing_raised do
-          Happening::S3::Request.new(:get, 'https://www.example.com', {:timeout => 4})
-        end
-      end
-    end
-    
-    context "when executing" do
-      should "have no response before executing" do
-        assert_nil Happening::S3::Request.new(:get, 'https://www.example.com').response
-      end
-      
-      should "call em-http-request" do
-        request = mock(:get => @response_stub)
-        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
-        Happening::S3::Request.new(:get, 'https://www.example.com').execute
-      end
-      
-      should "pass the given headers and options" do
-        request = mock('em-http-request')
-        request.expects(:get).with(:timeout => 10, :head => {'a' => 'b'}, :body => nil,  :ssl => {:verify_peer => false, :cert_chain_file => nil}).returns(@response_stub)
-        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
-        Happening::S3::Request.new(:get, 'https://www.example.com', :headers => {'a' => 'b'}).execute
-      end
-      
-      should "post any given data" do
-        request = mock('em-http-request')
-        request.expects(:put).with(:timeout => 10, :body => 'the-data', :head => {},  :ssl => {:verify_peer => false, :cert_chain_file => nil}).returns(@response_stub)
-        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
-        Happening::S3::Request.new(:put, 'https://www.example.com', :data => 'the-data').execute
-      end
-      
-      should "pass SSL options to em-http-request" do
-        request = mock('em-http-request')
-        request.expects(:put).with(:timeout => 10, :body => 'the-data', :head => {}, :ssl => {:verfiy_peer => true, :cert_chain_file => '/tmp/server.crt'}).returns(@response_stub)
-        EventMachine::MockHttpRequest.expects(:new).with('https://www.example.com').returns(request)
-        Happening::S3::Request.new(:put, 'https://www.example.com', :data => 'the-data', :ssl => {:verfiy_peer => true, :cert_chain_file => '/tmp/server.crt'}).execute
-      end
-      
-      context "when handling errors" do
-        should "call the user error handler" do
-          EventMachine::MockHttpRequest.register('http://www.example.com:80/', :get, {}, error_response(400))
-
-          called = false
-          on_error = Proc.new {|http| called = true}
-
-          run_in_em_loop do
-            Happening::S3::Request.new(:get, 'http://www.example.com/', :on_error => on_error).execute
-
-            EM.add_timer(1) {
-              EM.stop_event_loop
-              assert called
-              assert_equal 5, EventMachine::MockHttpRequest.count('http://www.example.com:80/', :get, {})
-            }
-
-          end
-        end
-        
-        should "use a default error handler if there is no user handler" do
-          EventMachine::MockHttpRequest.register('http://www.example.com:80/', :get, {}, error_response(400))
-
-          assert_raise(Happening::Error) do
-            run_in_em_loop do
-              Happening::S3::Request.new(:get, 'http://www.example.com/').execute
-            end
-          end
-          EM.stop_event_loop if EM.reactor_running?
-        end
-        
-      end
-      
-    end
-        
-  end
-end

data/test/s3_test.rb

@@ -1,32 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class S3Test < Test::Unit::TestCase
-  context "The Happening::S3 module" do
-    
-    should "allow to set global SSL options" do
-      assert Happening::S3.respond_to?(:ssl_options)
-      assert Happening::S3.respond_to?(:ssl_options=)
-    end
-    
-    should "set and get verify_peer" do
-      Happening::S3.ssl_options[:verify_peer] = true
-      assert Happening::S3.ssl_options[:verify_peer]
-      Happening::S3.ssl_options[:verify_peer] = false
-      assert !Happening::S3.ssl_options[:verify_peer]
-    end
-    
-    should "set and get cert_chain_file" do
-      Happening::S3.ssl_options[:cert_chain_file] = '/etc/cacert'
-      assert_equal '/etc/cacert', Happening::S3.ssl_options[:cert_chain_file]
-      Happening::S3.ssl_options[:cert_chain_file] = nil
-      assert_nil Happening::S3.ssl_options[:cert_chain_file]
-    end
-    
-    should "default to no certificate file and no verification" do
-      Happening::S3.instance_variable_set("@_ssl_options", nil)
-      assert !Happening::S3.ssl_options[:verify_peer]
-      assert_nil Happening::S3.ssl_options[:cert_chain_file]
-    end
-    
-  end
-end

data/test/test_helper.rb

@@ -1,94 +0,0 @@
-require 'rubygems'
-
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-$:.unshift(File.dirname(__FILE__) + "/../")
-
-require 'happening'
-
-require 'em-http/mock'
-
-EventMachine.instance_eval do
-  # Switching out EM's defer since it makes tests just a tad more unreliable
-  alias :defer_original :defer
-  def defer
-    yield
-  end
-end unless EM.respond_to?(:defer_original)
-
-class Test::Unit::TestCase
-  def setup
-    EventMachine::MockHttpRequest.reset_counts!
-    EventMachine::MockHttpRequest.reset_registry!
-  end
-  
-  def run_in_em_loop
-    EM.run {
-      yield
-    }
-  end
-end
-
-module Happening
-  module S3
-    class Request
-      def http_class
-        EventMachine::MockHttpRequest
-      end
-    end
-  end
-end
-
-def fake_response(data)
-  <<-HEREDOC
-HTTP/1.0 200 OK
-Date: Mon, 16 Nov 2009 20:39:15 GMT
-Expires: -1
-Cache-Control: private, max-age=0
-Content-Type: text/html; charset=ISO-8859-1
-Set-Cookie: PREF=ID=9454187d21c4a6a6:TM=1258403955:LM=1258403955:S=2-mf1n5oV5yAeT9-; expires=Wed, 16-Nov-2011 20:39:15 GMT; path=/; domain=.google.ca
-Set-Cookie: NID=28=lvxxVdiBQkCetu_WFaUxLyB7qPlHXS5OdAGYTqge_laVlCKVN8VYYeVBh4bNZiK_Oan2gm8oP9GA-FrZfMPC3ZMHeNq37MG2JH8AIW9LYucU8brOeuggMEbLNNXuiWg4; expires=Tue, 18-May-2010 20:39:15 GMT; path=/; domain=.google.ca; HttpOnly
-Server: gws
-X-XSS-Protection: 0
-X-Cache: MISS from .
-Via: 1.0 .:80 (squid)
-Connection: close
-
-#{data}
-HEREDOC
-end
-
-# amazon tells us to upload to another location, e.g. happening-benchmark.s3-external-3.amazonaws.com instead of happening-benchmark.s3.amazonaws.com
-def redirect_response(location)
-    <<-HEREDOC
-HTTP/1.0 301 Moved Permanently
-Date: Mon, 16 Nov 2009 20:39:15 GMT
-Expires: -1
-Cache-Control: private, max-age=0
-Content-Type: text/html; charset=ISO-8859-1
-Via: 1.0 .:80 (squid)
-Connection: close
-Location: #{location}
-
-<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>TemporaryRedirect</Code><Message>Please re-send this request to the specified temporary endpoint. Continue to use the original request endpoint for future requests.</Message><RequestId>137D5486D66095AE</RequestId><Bucket>happening-benchmark</Bucket><HostId>Nyk+Zq9GbtxcspdbKDWyGhsZhyUZquZP55tteYef4QVodsn73HUUad0xrIeD09lF</HostId><Endpoint>#{location}</Endpoint></Error>
-  HEREDOC
-end
-
-def error_response(error_code)
-  <<-HEREDOC
-HTTP/1.0 #{error_code} OK
-Date: Mon, 16 Nov 2009 20:39:15 GMT
-Content-Type: text/html; charset=ISO-8859-1
-Connection: close
-
-<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<Error><Code>TemporaryRedirect</Code><Message>Please re-send this request to the specified temporary endpoint. Continue to use the original request endpoint for future requests.</Message><RequestId>137D5486D66095AE</RequestId><Bucket>happening-benchmark</Bucket><HostId>Nyk+Zq9GbtxcspdbKDWyGhsZhyUZquZP55tteYef4QVodsn73HUUad0xrIeD09lF</HostId><Endpoint>https://s3.amazonaws.com</Endpoint></Error>
-HEREDOC
-end
-
-module EventMachine
-  class MockHttpRequest
-    @@pass_through_requests = false
-  end
-end