s3-publisher 0.4.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3a229558c18ee709daa8680c4d15d89cc832be0
-  data.tar.gz: ae139bdbc993ae23251f102c727bde45db901e6e
+  metadata.gz: 228be6f6a0276a570e4abae98164b259ce62bfa0
+  data.tar.gz: 7c489b18c2183fa36648ddd36b2afdcb0e8f86a6
 SHA512:
-  metadata.gz: 052acc3beae0da6d7eb63c3ffedfca7a55ea5e3db429d4f8b98b38acefcdc48d1770df7a15e6d73f28143c3426936b61e77bdbdfeea7496f1add05e029aeaec3
-  data.tar.gz: 6e9abb6df1e5b8e0d82b17d5fe6d1e7b81737ab54f5c529de26c962e3f8c50d8b470d833657829e1dec8128b169a99662e4a40824e4e257825204fadce1fe184
+  metadata.gz: 423f3fa87a913e384771e99d2f0c6a23016f95bc6bff62a7ef6d2d54977ade31e165f8af11dbfa0dfdcdde427e0ea915214474775370b41134b9b1c5ed36f4fe
+  data.tar.gz: b4e9a958d93e70cf6273198f87a593b377296806f83bdaa71f2aff28456ebe590ea6649ef7a5649d801dc6b7095445ca8d3a5bcad87b6f6c51b51c5baa807acc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/README.rdoc

@@ -1,39 +1,55 @@
-= s3-publisher
+# s3-publisher
 
-S3Publisher is meant as a clean, simple, sensible-defaults way to publish
-files to Amazon S3 for the world to see.
+Quickly pub your data files to S3.
 
-Basic usage:
+Reasons you might want to use this instead of aws-sdk directly:
 
-    require 's3-publisher'
-    S3Publisher.publish('my-bucket') do |p|
-        p.push('test.txt', 'abc1234')
-    end
+  * parallel uploads using ruby threads.  Concurrency defaults to 3 but can be increased.
+  * gzip, by default S3Publisher gzips so you don't have to.
+  * try-again technology, it will retry if a S3 request fails.
+  * no need to remember all the correct opts for content-type, acl, etc.
+
+### Basic usage:
+
+```
+require 's3-publisher'
+S3Publisher.publish('my-bucket') do |p|
+   p.push('test.txt', data: 'abc1234')
+end
+```
 
 This will:
-* push test.txt to my-bucket.s3.amazonaws.com
-* set security to public-read
-* gzip contents ('abc1234') and set a Content-Encoding: gzip header so clients know to decompress
-* set a Cache-Control: max-age=5 header
 
-Slightly more advanced example:
+ * push test.txt to my-bucket.s3.amazonaws.com
+ * set security to public-read
+ * gzip contents ('abc1234') and set a Content-Encoding: gzip header so clients know to decompress
+ * set a Cache-Control: max-age=5 header
+
+
+You can also pass file paths, rather than string data.  Files aren't read until publish-time, saving memory.
 
-    S3Publisher.publish('my-bucket', :base_path => 'world_cup') do |p|
-        p.push('events.xml', '<xml>...', :ttl => 15)
-    end
+```
+require 's3-publisher'
+S3Publisher.publish('my-bucket') do |p|
+   p.push('test.json', file: '/tmp/test.json')
+end
+```
+
+### Slightly more advanced example:
+
+```
+S3Publisher.publish('my-bucket', :base_path => 'world_cup') do |p|
+    p.push('events.xml', '<xml>...', :ttl => 15)
+end
+```
 
 In this example:
-* file will be written to my-bucket.s3.amazonaws.com/world_cup/events.xml
-* Cache-Control: max-age=15 will be set
+
+ * file will be written to my-bucket.s3.amazonaws.com/world_cup/events.xml
+ * Cache-Control: max-age=15 will be set
   
 A few miscellaneous notes:
-* gzip compress is skipped on .jpg/gif/png/tif files
-* uploads are multi-threaded.  You can control worker thread count on instantiation.
-* pass :redundancy => :reduced when instantiating the publisher to write to reduced
-redundancy storage (this used to be the default, but now requires the option to be set.)
-
-See class docs for further options.
 
-== Copyright
+ * gzip compress is skipped on .jpg/gif/png/tif files
 
-Copyright (c) 2011 Ben Koski. See LICENSE for details.
+See class docs for more options.

data/lib/s3-publisher.rb

@@ -1,10 +1,9 @@
 require 'zlib'
 require 'thread'
+require 'pathname'
 
-require 'right_aws'
-require 'aws_credentials'
-
-Thread.abort_on_exception = true
+require 'aws-sdk'
+require 'mime-types'
 
 # You can either use the block syntax, or:
 # * instantiate a class
@@ -24,54 +23,71 @@ class S3Publisher
     p.run
   end
 
-  # Pass the publisher a bucket_name along with any of the following options:
-  # * <tt>base_path</tt> - path prepended to supplied file_name on upload
-  # * <tt>logger</tt> - a logger object to recieve 'uploaded' messages.  Defaults to STDOUT.
-  # * <tt>protocol</tt> - protocol to use for S3 requests. Defaults to 'http', but 'https' can also be used.
-  # * <tt>workers</tt> - number of threads to use when pushing to S3. Defaults to 3.
+  # @param [String] bucket_name
+  # @option opts [String] :base_path Path prepended to supplied file_name on upload
+  # @option opts [Integer] :workers Number of threads to use when pushing to S3. Defaults to 3.
+  # @option opts [Object] :logger A logger object to recieve 'uploaded' messages.  Defaults to STDOUT.
   def initialize bucket_name, opts={}
-    @s3 =  RightAws::S3.new(AWSCredentials.access_key, AWSCredentials.secret_access_key, :multi_thread => true,
-                                                                                         :protocol => opts[:protocol] || 'http',
-                                                                                         :port => 80, 
-                                                                                         :logger => Logger.new(nil))
-    @bucket_name, @base_path = bucket_name, opts[:base_path]
-    raise ArgumentError, "#{bucket_name} doesn't seem to be a valid bucket on your account" if @s3.bucket(bucket_name).nil?
-    @logger = opts[:logger] || $stdout
-    @workers_to_use = opts[:workers] || 3
     @publish_queue = Queue.new
+    @workers_to_use = opts[:workers] || 3
+    @logger = opts[:logger] || $stdout
+
+    s3_opts = {}
+    s3_opts[:access_key_id]     = opts[:access_key_id]     if opts.key?(:access_key_id)
+    s3_opts[:secret_access_key] = opts[:secret_access_key] if opts.key?(:secret_access_key)
+    
+    @s3 = AWS::S3.new(s3_opts)
+
+    @bucket_name, @base_path = bucket_name, opts[:base_path]
+    raise ArgumentError, "#{bucket_name} doesn't seem to be a valid bucket on your account" if @s3.buckets[bucket_name].nil?
   end
-  
-  # Pass:
-  # * <tt>file_name</tt> - name of file on S3. base_path will be prepended if supplied on instantiate.
-  # * <tt>data</tt> - data to be uploaded as a string
+
+  # Queues a file to be published.
+  # You can provide :data as a string, or a path to a file with :file.
+  # :file references won't be evaluated until publish-time, reducing memory overhead.
   #
-  # And one or many options:
-  # * <tt>:gzip (true|false)</tt> - gzip file contents?  defaults to true.
-  # * <tt>:ttl</tt> - TTL in seconds for cache-control header. defaults to 5.
-  # * <tt>:cache_control</tt> - specify Cache-Control header directly if you don't like the default
-  # * <tt>:content_type</tt> - no need to specify if default based on extension is okay.  But if you need to force,
-  #   you can provide :xml, :html, :text, or your own custom string.
-  # * <tt>:redundancy</tt> - by default objects are stored at reduced redundancy, pass :standard to store at full
-  def push file_name, data, opts={}
-    headers = {}
+  # @param [String] key_name  The name of the file on S3.  base_path will be prepended if supplied.
+  # @option opts [String] :data  a string to be published
+  # @option opts [String] :file  path to a file to publish
+  # @option opts [Boolean] :gzip  gzip file contents?  defaults to true.
+  # @option opts [Integer] :ttl  TTL in seconds for cache-control header. defaults to 5.
+  # @option opts [String] :cache_control  specify Cache-Control header directly if you don't like the default
+  # @option opts [String] :content_type  no need to specify if default based on extension is okay.  But if you need to force,
+  #                                      you can provide :xml, :html, :text, or your own custom string.
+  def push key_name, opts={}
+    write_opts = { acl: 'public-read' }
     
-    file_name = "#{base_path}/#{file_name}" unless base_path.nil?
+    key_name = "#{base_path}/#{key_name}" unless base_path.nil?
     
-    unless opts[:gzip] == false || file_name.match(/\.(jpg|gif|png|tif)$/)
-      data = gzip(data)
-      headers['Content-Encoding'] = 'gzip'
+    # Setup data.
+    if opts[:data]
+      contents = opts[:data]
+    elsif opts[:file]
+      contents = Pathname.new(opts[:file])
+      raise ArgumentError, "'#{opts[:file]}' does not exist!" if !contents.exist?
+    else
+      raise ArgumentError, "A :file or :data attr must be provided to publish to S3!"
+    end
+
+    # Then Content-Type
+    if opts[:content_type]
+      write_opts[:content_type] = opts[:content_type]
+    else
+      matching_mimes = MIME::Types.type_for(key_name)
+      raise  ArgumentError, "Can't infer the content-type for '#{key_name}'! Please specify with the :content_type opt." if matching_mimes.empty?
+      write_opts[:content_type] = matching_mimes.first.to_s
     end
-    
-    headers['x-amz-storage-class'] = opts[:redundancy] == :reduced ? 'REDUCED_REDUNDANCY' : 'STANDARD'
-    headers['content-type']        = parse_content_type(opts[:content_type])  if opts[:content_type]
 
+    # And Cache-Control
     if opts.has_key?(:cache_control)
-      headers['Cache-Control'] = opts[:cache_control]
+      write_opts[:cache_control] = opts[:cache_control]
     else
-      headers['Cache-Control'] = "max-age=#{opts[:ttl] || 5}"
+      write_opts[:cache_control] = "max-age=#{opts[:ttl] || 5}"
     end
 
-    @publish_queue.push({:key_name => file_name, :data => data, :headers => headers})
+    opts[:gzip] = true unless opts.has_key?(:gzip)
+
+    @publish_queue.push({ key_name: key_name, contents: contents, write_opts: write_opts, gzip: opts[:gzip] })
   end  
     
   # Process queued uploads and push to S3
@@ -96,19 +112,6 @@ class S3Publisher
     
     return gzipped_data.string
   end
-    
-  def parse_content_type content_type
-    case content_type
-    when :xml
-      'application/xml'
-    when :text
-      'text/plain'
-    when :html
-      'text/html'
-    else
-      content_type
-    end
-  end
   
   def publish_from_queue
     loop do
@@ -116,14 +119,25 @@ class S3Publisher
     
       try_count = 0
       begin
-        @s3.bucket(bucket_name).put(item[:key_name], item[:data], {}, 'public-read', item[:headers])
+        obj = @s3.buckets[bucket_name].objects[item[:key_name]]
+
+        gzip = item[:gzip] != false && !item[:key_name].match(/\.(jpg|gif|png|tif)$/)
+
+        if gzip
+          item[:write_opts][:content_encoding] = 'gzip'
+          gzip_body = item[:contents].is_a?(Pathname) ? item[:contents].read : item[:contents]
+          item[:contents] = gzip(gzip_body)
+        end
+
+        obj.write(item[:contents], item[:write_opts])
+
       rescue Exception => e # backstop against transient S3 errors
         raise e if try_count >= 1
         try_count += 1
         retry
       end
     
-      logger << "Wrote http://#{bucket_name}.s3.amazonaws.com/#{item[:key_name]} with #{item[:headers].inspect}\n"
+      logger << "Wrote http://#{bucket_name}.s3.amazonaws.com/#{item[:key_name]} with #{item[:write_opts].inspect}\n"
     end
   rescue ThreadError  # ThreadError hit when queue is empty.  Simply jump out of loop and return to join().
   end

data/s3-publisher.gemspec

@@ -2,9 +2,9 @@
 
 Gem::Specification.new do |s|
   s.name        = "s3-publisher"
-  s.version     = "0.4.4"
+  s.version     = "0.9.0"
   s.authors     = ["Ben Koski"]
-  s.email       = "gems@benkoski.com"
+  s.email       = "bkoski@nytimes.com"
   s.summary     = "Publish data to S3 for the world to see"
   s.description = "Publish data to S3 for the world to see"
   s.homepage    = "http://github.com/bkoski/s3-publisher"
@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
 
   s.require_paths = ["lib"]
 
-  s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-  s.add_runtime_dependency(%q<aws_credentials>, [">= 0"])
-  s.add_runtime_dependency(%q<right_aws>, [">= 3.0.0"])
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_runtime_dependency(%q<aws-sdk>, [">= 1.0"])
+  s.add_runtime_dependency(%q<mime-types>, [">= 0"])
 end

data/spec/s3_publisher_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe S3Publisher do  
+  describe "#push" do
+           
+    describe "file_name" do
+      it "prepends base_path if provided" do
+        set_put_expectation(key_name: 'world_cup_2010/events.xml')
+        p = S3Publisher.new('test-bucket', :logger => Logger.new(nil), :base_path => 'world_cup_2010')
+        p.push('events.xml', data: '1234')
+        p.run
+      end
+      
+      it "passes name through unaltered if base_path not specified" do
+        set_put_expectation(key_name: 'events.xml')
+        p = S3Publisher.new('test-bucket', :logger => Logger.new(nil))
+        p.push('events.xml', data: '1234')
+        p.run
+      end      
+    end
+    
+    describe "gzip" do
+      it "gzips data if :gzip => true" do
+        set_put_expectation(data: gzip('1234'))
+        push_test_data('myfile.txt', data: '1234', gzip: true)
+      end
+      
+      it "does not gzip data if :gzip => false" do
+        set_put_expectation(data: '1234')
+        push_test_data('myfile.txt', data: '1234', gzip: false)
+      end
+
+      it "does not gzip data if file ends in .jpg" do
+        set_put_expectation(key_name: 'myfile.jpg', data: '1234')
+        push_test_data('myfile.jpg', data: '1234')
+      end
+      
+      it "gzips data by default" do
+        set_put_expectation(data: gzip('1234'))
+        push_test_data('myfile.txt', data: '1234')
+      end
+    end
+
+    describe ":file opt" do
+      it "queues files as a pathname to be read if gzip is false" do
+        set_put_expectation(file: __FILE__)
+        push_test_data('myfile.txt', file: __FILE__, gzip: false)
+      end
+
+      it "queues gzipped contents of the file if gzip is true" do
+        set_put_expectation(data: gzip(File.read(__FILE__)))
+        push_test_data('myfile.txt', file: __FILE__, gzip: true)
+      end
+    end
+    
+    describe "content type" do
+      it "detects content type based on extension" do
+        set_put_expectation(key_name: 'myfile.xml', content_type: 'application/xml')
+        push_test_data('myfile.xml', data: '1234')
+      end
+      
+      it "forces Content-Type to user-supplied string if provided" do
+        set_put_expectation(content_type: 'audio/vorbis')
+        push_test_data('myfile.txt', data: '1234', content_type: 'audio/vorbis')
+      end
+
+      it "raises an exception if the content-type cannot be parsed" do
+        expect { push_test_data('myfile', data: '1234') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "cache-control" do
+      it "sets Cache-Control to user-supplied string if :cache_control provided" do
+        set_put_expectation(cache_control: 'private, max-age=0')
+        push_test_data('myfile.txt', data: '1234', cache_control: 'private, max-age=0')
+      end
+      
+      it "sets Cache-Control with :ttl provided" do
+        set_put_expectation(cache_control: 'max-age=55')
+        push_test_data('myfile.txt', data: '1234', ttl: 55)
+      end
+      
+      it "sets Cache-Control to a 5s ttl if no :ttl or :cache_control was provided" do
+        set_put_expectation(cache_control: 'max-age=5')
+        push_test_data('myfile.txt', data: '1234')
+      end
+    end
+    
+    # Based on opts, sets expecations for AWS::S3Object.write
+    # Can provide expected values for:
+    #  * :key_name
+    #  * :data
+    #  * :content_type, :cache_control, :content_encoding
+    def set_put_expectation opts
+      s3_stub = mock()
+      bucket_stub = mock()
+      object_stub = mock()
+
+      key_name = opts[:key_name] || 'myfile.txt'
+
+      expected_entries = {}
+      [:content_type, :cache_control, :content_encoding].each do |k|
+        expected_entries[k] = opts[k] if opts.has_key?(k)
+      end
+
+      if opts[:data]
+        expected_contents = opts[:data]
+      elsif opts[:file]
+        expected_contents = Pathname.new(opts[:file])
+      else
+        expected_contents = anything
+      end
+
+      object_stub.expects(:write).with(expected_contents, has_entries(expected_entries))
+
+      s3_stub.stubs(:buckets).returns({'test-bucket' => bucket_stub })
+      bucket_stub.stubs(:objects).returns({ key_name => object_stub })
+      
+      AWS::S3.stubs(:new).returns(s3_stub)
+    end
+    
+    def gzip data
+      gzipped_data = StringIO.open('', 'w+')
+      
+      gzip_writer = Zlib::GzipWriter.new(gzipped_data)
+      gzip_writer.write(data)
+      gzip_writer.close
+      
+      return gzipped_data.string
+    end
+    
+    def push_test_data file_name, opts
+      p = S3Publisher.new('test-bucket', :logger => Logger.new(nil))
+      p.push(file_name, opts)
+      p.run
+    end
+  end  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require File.expand_path('../lib/s3-publisher.rb', File.dirname(__FILE__))
+
+RSpec.configure do |config|
+  # Limit the spec run to only specs with the focus metadata. If no specs have
+  # the filtering metadata and `run_all_when_everything_filtered = true` then
+  # all specs will run.
+  #config.filter_run :focus
+
+  # Run all specs when none match the provided filter. This works well in
+  # conjunction with `config.filter_run :focus`, as it will run the entire
+  # suite when no specs have `:filter` metadata.
+  #config.run_all_when_everything_filtered = true
+  config.mock_framework = :mocha
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = 'random'
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: s3-publisher
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Ben Koski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-14 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thoughtbot-shoulda
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -25,40 +25,41 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: aws_credentials
+  name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: right_aws
+  name: mime-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '0'
 description: Publish data to S3 for the world to see
-email: gems@benkoski.com
+email: bkoski@nytimes.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -66,8 +67,8 @@ files:
 - Rakefile
 - lib/s3-publisher.rb
 - s3-publisher.gemspec
-- test/s3-publisher_test.rb
-- test/test_helper.rb
+- spec/s3_publisher_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/bkoski/s3-publisher
 licenses:
 - MIT
@@ -88,10 +89,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Publish data to S3 for the world to see
 test_files:
-- test/s3-publisher_test.rb
-- test/test_helper.rb
+- spec/s3_publisher_spec.rb
+- spec/spec_helper.rb

data/test/s3-publisher_test.rb

@@ -1,127 +0,0 @@
-require 'test_helper'
-
-class S3PublisherTest < Test::Unit::TestCase
-  
-  context "push" do
-           
-    context "file_name" do
-      should "prepend base_path if provided on instantiate" do
-        set_put_expectation(:key_name => 'world_cup_2010/events.xml')
-        p = S3Publisher.new('test-bucket', :logger => Logger.new(nil), :base_path => 'world_cup_2010')
-        p.push('events.xml', '1234')
-        p.run
-      end
-      
-      should "pass through unaltered if base_path not specified" do
-        set_put_expectation(:key_name => 'events.xml')
-        p = S3Publisher.new('test-bucket', :logger => Logger.new(nil))
-        p.push('events.xml', '1234')
-        p.run
-      end      
-    end
-    
-    context "gzip" do
-      should "gzip data if :gzip => true" do
-        set_put_expectation(:data => gzip('1234'))
-        push_test_data('myfile.txt', '1234', :gzip => true)
-      end
-      
-      should "not gzip data if :gzip => false" do
-        set_put_expectation(:data => '1234')
-        push_test_data('myfile.txt', '1234', :gzip => false)
-      end
-
-      should "not gzip data if file ends in .jpg" do
-        set_put_expectation(:data => '1234')
-        push_test_data('myfile.jpg', '1234', {})
-      end
-      
-      should "gzip data by default" do
-        set_put_expectation(:data => gzip('1234'))
-        push_test_data('myfile.txt', '1234', {})
-      end
-    end
-    
-    context "redundancy" do
-      should "set STANDARD by default" do
-        set_put_expectation(:headers => { 'x-amz-storage-class' => 'STANDARD' })
-        push_test_data('myfile.txt', '1234', {})
-
-      end
-      
-      should "set REDUCED_REDUNDANCY if :redundancy => :reduced is passed" do
-        set_put_expectation(:headers => { 'x-amz-storage-class' => 'REDUCED_REDUNDANCY' })
-        push_test_data('myfile.txt', '1234', :redundancy => :reduced)
-      end
-    end
-
-    context "content type" do
-      should "force Content-Type to user-supplied string if provided" do
-        set_put_expectation(:headers => { 'Content-Type' => 'audio/vorbis' })
-        push_test_data('myfile.txt', '1234', :content_type => 'audio/vorbis')
-      end
-      
-      should "force Content-Type to application/xml if :xml provided" do
-        set_put_expectation(:headers => { 'Content-Type' => 'application/xml' })
-        push_test_data('myfile.txt', '1234', :content_type => :xml)
-      end
-      
-      should "force Content-Type to text/plain if :text provided" do
-        set_put_expectation(:headers => { 'Content-Type' => 'text/plain' })
-        push_test_data('myfile.txt', '1234', :content_type => :text)
-      end
-      
-      should "force Content-Type to text/html if :html provided" do
-        set_put_expectation(:headers => { 'Content-Type' => 'text/html' })
-        push_test_data('myfile.txt', '1234', :content_type => :html)
-      end
-    end
-
-    context "cache-control" do
-      should "set Cache-Control to user-supplied string if :cache_control provided" do
-        set_put_expectation(:headers => { 'Cache-Control' => 'private, max-age=0' })
-        push_test_data('myfile.txt', '1234', :cache_control => 'private, max-age=0')
-      end
-      
-      should "set Cache-Control with :ttl provided" do
-        set_put_expectation(:headers => { 'Cache-Control' => 'max-age=55' })
-        push_test_data('myfile.txt', '1234', :ttl => 55)
-      end
-      
-      should "set Cache-Control to a 5s ttl if no :ttl or :cache_control was provided" do
-        set_put_expectation(:headers => { 'Cache-Control' => 'max-age=5' })
-        push_test_data('myfile.txt', '1234', {})
-      end
-    end
-    
-    
-    
-    
-  end
-  
-  def set_put_expectation opts
-    s3_stub = mock()
-    bucket_stub = mock()
-    bucket_stub.expects(:put).with(opts[:key_name] || anything, opts[:data] || anything, {}, 'public-read', opts[:headers] ? has_entries(opts[:headers]) : anything)
-    
-    s3_stub.stubs(:bucket).returns(bucket_stub)
-    RightAws::S3.stubs(:new).returns(s3_stub)
-  end
-  
-  def gzip data
-    gzipped_data = StringIO.open('', 'w+')
-    
-    gzip_writer = Zlib::GzipWriter.new(gzipped_data)
-    gzip_writer.write(data)
-    gzip_writer.close
-    
-    return gzipped_data.string
-  end
-  
-  def push_test_data file_name, data, opts
-    p = S3Publisher.new('test-bucket', :logger => Logger.new(nil))
-    p.push(file_name, data, opts)
-    p.run
-  end
-  
-end

data/test/test_helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 's3-publisher'
-
-class Test::Unit::TestCase
-end