carrierwave-rails3 0.4.5

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+
+require 'tempfile'
+#require 'ruby-debug'
+require 'spec'
+require 'spec/autorun'
+
+require 'carrierwave'
+require 'timecop'
+require 'time'
+require 'json'
+
+require 'logger'
+
+alias :running :lambda
+
+def file_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', *paths))
+end
+
+def public_path( *paths )
+  File.expand_path(File.join(File.dirname(__FILE__), 'public', *paths))
+end
+
+CarrierWave.root = public_path
+
+module CarrierWave
+  module Test
+    module MockStorage
+      def mock_storage(kind)
+        storage = mock("storage for #{kind} uploader")
+        storage.stub!(:setup!)
+        storage
+      end
+    end
+    
+    module MockFiles
+      def stub_merb_tempfile(filename)
+        raise "#{path} file does not exist" unless File.exist?(file_path(filename))
+
+        t = Tempfile.new(filename)
+        FileUtils.copy_file(file_path(filename), t.path)
+    
+        return t
+      end
+  
+      def stub_tempfile(filename, mime_type=nil, fake_name=nil)
+        raise "#{path} file does not exist" unless File.exist?(file_path(filename))
+
+        t = Tempfile.new(filename)
+        FileUtils.copy_file(file_path(filename), t.path)
+    
+        # This is stupid, but for some reason rspec won't play nice...
+        eval <<-EOF
+        def t.original_filename; '#{fake_name || filename}'; end
+        def t.content_type; '#{mime_type}'; end
+        def t.local_path; path; end
+        EOF
+
+        return t
+      end
+
+      def stub_stringio(filename, mime_type=nil, fake_name=nil)
+        if filename
+          t = StringIO.new( IO.read( file_path( filename ) ) )
+        else
+          t = StringIO.new
+        end
+        t.stub!(:local_path).and_return("")
+        t.stub!(:original_filename).and_return(filename || fake_name)
+        t.stub!(:content_type).and_return(mime_type)
+        return t
+      end
+
+      def stub_file(filename, mime_type=nil, fake_name=nil)
+        f = File.open(file_path(filename))
+        return f
+      end
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include CarrierWave::Test::Matchers
+  config.include CarrierWave::Test::MockFiles
+  config.include CarrierWave::Test::MockStorage
+end

data/spec/storage/cloudfiles_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+if ENV['CLOUDFILES_SPEC']
+  require 'cloudfiles'
+  require 'net/http'
+
+  describe CarrierWave::Storage::CloudFiles do
+    before do
+      @uploader = mock('an uploader')
+      @uploader.stub!(:cloud_files_username).and_return(ENV["CLOUD_FILES_USER_NAME"])
+      @uploader.stub!(:cloud_files_api_key).and_return(ENV["CLOUD_FILES_API_KEY"])
+      @uploader.stub!(:cloud_files_container).and_return(ENV['CARRIERWAVE_TEST_CONTAINER'])
+      @storage = CarrierWave::Storage::CloudFiles.new(@uploader)
+      @file = stub_tempfile('test.jpg', 'application/xml')
+      
+      @cf = CloudFiles::Connection.new(ENV["CLOUD_FILES_USER_NAME"], ENV["CLOUD_FILES_API_KEY"])
+      @container = @cf.container(@uploader.cloud_files_container)
+    end
+  
+    describe '#store!' do
+      before do
+        @uploader.stub!(:store_path).and_return('uploads/bar.txt')
+        @cloud_file = @storage.store!(@file)
+      end
+    
+      it "should upload the file to Cloud Files" do
+        @container.object('uploads/bar.txt').data.should == 'this is stuff'
+      end
+    
+      it "should have a path" do
+        @cloud_file.path.should == 'uploads/bar.txt'
+      end
+          
+      it "should have an Rackspace URL" do
+        @cloud_file.url.should =~ %r!http://(.*?).cdn.cloudfiles.rackspacecloud.com/uploads/bar.txt!
+      end
+      
+      it "should store the content type on Cloud Files" do
+        @cloud_file.content_type.should == 'application/xml'
+      end
+      
+      it "should be deletable" do
+        @cloud_file.delete
+        @container.object_exists?('uploads/bar.txt').should be_false
+      end
+      
+    end
+      
+    describe '#retrieve!' do
+      before do
+        @container.create_object('uploads/bar.txt').write("A test, 1234")
+        @uploader.stub!(:store_path).with('bar.txt').and_return('uploads/bar.txt')
+      
+        @cloud_file = @storage.retrieve!('bar.txt')
+      end
+    
+      it "should retrieve the file contents from Cloud Files" do
+        @cloud_file.read.chomp.should == "A test, 1234"
+      end
+    
+      it "should have a path" do
+        @cloud_file.path.should == 'uploads/bar.txt'
+      end
+    
+      it "should have an Rackspace URL" do
+        @cloud_file.url.should =~ %r!http://(.*?).cdn.cloudfiles.rackspacecloud.com/uploads/bar.txt!
+      end
+    
+      it "should be deletable" do
+        @cloud_file.delete
+        @container.object_exists?('uploads/bar.txt').should be_false
+      end
+    end
+
+  end
+end

data/spec/storage/grid_fs_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mongo'
+
+describe CarrierWave::Storage::GridFS do
+
+  before do
+    @database = Mongo::Connection.new('localhost', 27017).db('carrierwave_test')
+    @uploader = mock('an uploader')
+    @uploader.stub!(:grid_fs_database).and_return("carrierwave_test")
+    @uploader.stub!(:grid_fs_host).and_return("localhost")
+    @uploader.stub!(:grid_fs_port).and_return(27017)
+    @uploader.stub!(:grid_fs_access_url).and_return(nil)
+    @uploader.stub!(:grid_fs_username).and_return(nil)
+    @uploader.stub!(:grid_fs_password).and_return(nil)
+    
+    @grid = Mongo::GridFileSystem.new(@database)
+
+    @storage = CarrierWave::Storage::GridFS.new(@uploader)
+    @file = stub_tempfile('test.jpg', 'application/xml')
+  end
+  
+  after do
+    @grid.delete('uploads/bar.txt')
+  end
+
+  describe '#store!' do
+    before do
+      @uploader.stub!(:store_path).and_return('uploads/bar.txt')
+      @grid_fs_file = @storage.store!(@file)
+    end
+    
+    it "should upload the file to gridfs" do
+      @grid.open('uploads/bar.txt', 'r').data.should == 'this is stuff'
+    end
+    
+    it "should not have a path" do
+      @grid_fs_file.path.should be_nil
+    end
+    
+    it "should not have a URL" do
+      @grid_fs_file.url.should be_nil
+    end
+    
+    it "should be deletable" do
+      @grid_fs_file.delete
+      lambda {@grid.open('uploads/bar.txt', 'r')}.should raise_error(Mongo::GridFileNotFound)
+    end
+    
+    it "should store the content type on GridFS" do
+      @grid_fs_file.content_type.should == 'application/xml'
+    end
+  end
+  
+  describe '#retrieve!' do
+    before do
+      @grid.open('uploads/bar.txt', 'w') { |f| f.write "A test, 1234" }
+      @uploader.stub!(:store_path).with('bar.txt').and_return('uploads/bar.txt')
+      @grid_fs_file = @storage.retrieve!('bar.txt')
+    end
+
+    it "should retrieve the file contents from gridfs" do
+      @grid_fs_file.read.chomp.should == "A test, 1234"
+    end
+    
+    it "should not have a path" do
+      @grid_fs_file.path.should be_nil
+    end
+    
+    it "should not have a URL unless set" do
+      @grid_fs_file.url.should be_nil
+    end
+    
+    it "should return a URL if configured" do
+      @uploader.stub!(:grid_fs_access_url).and_return("/image/show")
+      @grid_fs_file.url.should == "/image/show/uploads/bar.txt"
+    end
+    
+    it "should be deletable" do
+      @grid_fs_file.delete
+      lambda {@grid.open('uploads/bar.txt', 'r')}.should raise_error(Mongo::GridFileNotFound)
+    end
+  end
+
+end

data/spec/storage/s3_spec.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'aws'
+
+if ENV['S3_SPEC']
+  describe CarrierWave::Storage::S3 do
+    before do
+      @bucket = ENV['CARRIERWAVE_TEST_BUCKET']
+      @uploader = mock('an uploader')
+      @uploader.stub!(:s3_access_key_id).and_return(ENV["S3_ACCESS_KEY_ID"])
+      @uploader.stub!(:s3_secret_access_key).and_return(ENV["S3_SECRET_ACCESS_KEY"])
+      @uploader.stub!(:s3_bucket).and_return(@bucket)
+      @uploader.stub!(:s3_access_policy).and_return('public-read')
+      @uploader.stub!(:s3_cnamed).and_return(false)
+      @uploader.stub!(:s3_multi_thread).and_return(true)
+      @uploader.stub!(:s3_headers).and_return({'Expires' => 'Fri, 21 Jan 2021 16:51:06 GMT'})
+
+      @storage = CarrierWave::Storage::S3.new(@uploader)
+      @file = CarrierWave::SanitizedFile.new(file_path('test.jpg'))
+    end
+  
+    after do
+      @storage.connection.delete(@bucket, 'uploads/bar.txt')
+    end
+
+    describe 'general setup' do
+      before(:each) do
+        @uploader.stub!(:s3_access_policy).and_return(nil)
+        @uploader.stub!(:s3_access).and_return(nil)
+        @s3_file = CarrierWave::Storage::S3::File.new(@uploader, @storage, 'uploads/bar.txt')
+      end
+
+      it "should use the default public-read access policy" do
+        @s3_file.access_policy.should eql('public-read')
+      end
+
+      it "should use provided access policy" do
+        @uploader.stub!(:s3_access_policy).and_return('bucket-owner-read')
+        @s3_file.access_policy.should eql('bucket-owner-read')
+      end
+
+      it "should use old s3_access config if s3_access_policy not set" do
+        @uploader.stub!(:s3_access).and_return(:public_read_write)
+        @s3_file.access_policy.should eql('public-read-write')
+      end
+    end
+
+    describe '#store!' do
+      before do
+        @uploader.stub!(:store_path).and_return('uploads/bar.txt')
+        @s3_file = @storage.store!(@file)
+      end
+    
+      it "should upload the file to s3" do
+        @storage.connection.get_object(@bucket, 'uploads/bar.txt').should == 'this is stuff'
+      end
+    
+      it "should have a path" do
+        @s3_file.path.should == 'uploads/bar.txt'
+      end
+   
+      context "without cnamed bucket" do
+        it "should have a Euro supported Amazon URL" do
+          @uploader.stub!(:s3_cnamed).and_return(false)
+          @uploader.stub!(:s3_bucket).and_return('foo.bar')
+          @s3_file.url.should == "http://foo.bar.s3.amazonaws.com/uploads/bar.txt"
+        end
+      end
+      
+      context "with cnamed bucket" do
+        it "should have a CNAMED URL" do
+          @uploader.stub!(:s3_cnamed).and_return(true)
+          @uploader.stub!(:s3_bucket).and_return('foo.bar')
+          @s3_file.url.should == 'http://foo.bar/uploads/bar.txt'
+        end
+      end
+      
+      it "should be deletable" do
+        @s3_file.delete
+        lambda {@storage.connection.head(@bucket, 'uploads/bar.txt')}.should raise_error(Aws::AwsError)
+      end
+      
+      it "should set headers" do
+        client = Net::HTTP.new("#{@bucket}.s3.amazonaws.com")
+        headers = client.request_head('/uploads/bar.txt')
+        headers["Expires"].should == 'Fri, 21 Jan 2021 16:51:06 GMT'
+      end
+
+    end
+  
+    describe '#retrieve!' do
+      before do
+        @storage.connection.put(@bucket, "uploads/bar.txt", "A test, 1234", {'a-amz-acl' => 'public-read'})
+        @uploader.stub!(:store_path).with('bar.txt').and_return('uploads/bar.txt')
+        @s3_file = @storage.retrieve!('bar.txt')
+      end
+
+      it "should retrieve the file contents from s3" do
+        @s3_file.read.chomp.should == "A test, 1234"
+      end
+    
+      it "should have a path" do
+        @s3_file.path.should == 'uploads/bar.txt'
+      end
+    
+      it "should have an Amazon URL" do
+        @s3_file.url.should == "http://#{@bucket}.s3.amazonaws.com/uploads/bar.txt"
+      end
+    
+      it "should be deletable" do
+        @s3_file.delete
+        lambda {@storage.connection.head(@bucket, 'uploads/bar.txt')}.should raise_error(Aws::AwsError)
+      end
+    end
+
+  end
+end

data/spec/uploader/cache_spec.rb

@@ -0,0 +1,209 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe CarrierWave::Uploader do
+
+  before do
+    @uploader_class = Class.new(CarrierWave::Uploader::Base)
+    @uploader = @uploader_class.new
+  end
+  
+  after do
+    FileUtils.rm_rf(public_path)
+  end
+
+  describe '.clean_cached_files!' do
+    before do
+      @cache_dir = File.expand_path(@uploader_class.cache_dir, CarrierWave.root)
+      FileUtils.mkdir_p File.expand_path('20071201-1234-234-2213', @cache_dir)
+      FileUtils.mkdir_p File.expand_path('20071203-1234-234-2213', @cache_dir)
+      FileUtils.mkdir_p File.expand_path('20071205-1234-234-2213', @cache_dir)
+    end
+
+    after { FileUtils.rm_rf(@cache_dir) }
+
+    it "should clear all files older than 24 hours in the default cache directory" do
+      Timecop.freeze(Time.parse('2007-12-06 10:12')) do
+        @uploader_class.clean_cached_files!
+      end
+      Dir.glob("#{@cache_dir}/*").should have(1).element
+    end
+
+    it "should be aliased on the CarrierWave module" do
+      Timecop.freeze(Time.parse('2007-12-06 10:12')) do
+        CarrierWave.clean_cached_files!
+      end
+      Dir.glob("#{@cache_dir}/*").should have(1).element
+    end
+  end
+
+  describe '#cache_dir' do
+    it "should default to the config option" do
+      @uploader.cache_dir.should == 'uploads/tmp'
+    end
+  end
+
+  describe '#cache!' do
+
+    before do
+      CarrierWave.stub!(:generate_cache_id).and_return('20071201-1234-345-2255')
+    end
+
+    it "should cache a file" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.file.should be_an_instance_of(CarrierWave::SanitizedFile)
+    end
+
+    it "should be cached" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.should be_cached
+    end
+
+    it "should store the cache name" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.cache_name.should == '20071201-1234-345-2255/test.jpg'
+    end
+
+    it "should set the filename to the file's sanitized filename" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.filename.should == 'test.jpg'
+    end
+
+    it "should move it to the tmp dir" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.file.path.should == public_path('uploads/tmp/20071201-1234-345-2255/test.jpg')
+      @uploader.file.exists?.should be_true
+    end
+
+    it "should set the url" do
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.url.should == '/uploads/tmp/20071201-1234-345-2255/test.jpg'
+    end
+
+    it "should raise an error when trying to cache a string" do
+      running {
+        @uploader.cache!(file_path('test.jpg'))
+      }.should raise_error(CarrierWave::FormNotMultipart)
+    end
+
+    it "should raise an error when trying to cache a pathname" do
+      running {
+        @uploader.cache!(Pathname.new(file_path('test.jpg')))
+      }.should raise_error(CarrierWave::FormNotMultipart)
+    end
+
+    it "should do nothing when trying to cache an empty file" do
+      @uploader.cache!(nil)
+    end
+
+    it "should set permissions if options are given" do
+      @uploader_class.permissions = 0777
+
+      @uploader.cache!(File.open(file_path('test.jpg')))
+      @uploader.should have_permissions(0777)
+    end
+  end
+
+  describe '#retrieve_from_cache!' do
+    it "should cache a file" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.file.should be_an_instance_of(CarrierWave::SanitizedFile)
+    end
+
+    it "should be cached" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.should be_cached
+    end
+
+    it "should set the path to the tmp dir" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.current_path.should == public_path('uploads/tmp/20071201-1234-345-2255/test.jpeg')
+    end
+
+    it "should overwrite a file that has already been cached" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/bork.txt')
+      @uploader.current_path.should == public_path('uploads/tmp/20071201-1234-345-2255/bork.txt')
+    end
+
+    it "should store the cache_name" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.cache_name.should == '20071201-1234-345-2255/test.jpeg'
+    end
+
+    it "should store the filename" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.filename.should == 'test.jpeg'
+    end
+
+    it "should set the url" do
+      @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpeg')
+      @uploader.url.should == '/uploads/tmp/20071201-1234-345-2255/test.jpeg'
+    end
+
+    it "should raise an error when the cache_id has an invalid format" do
+      running {
+        @uploader.retrieve_from_cache!('12345/test.jpeg')
+      }.should raise_error(CarrierWave::InvalidParameter)
+
+      @uploader.file.should be_nil
+      @uploader.filename.should be_nil
+      @uploader.cache_name.should be_nil
+    end
+
+    it "should raise an error when the original_filename contains invalid characters" do
+      running {
+        @uploader.retrieve_from_cache!('20071201-1234-345-2255/te/st.jpeg')
+      }.should raise_error(CarrierWave::InvalidParameter)
+      running {
+        @uploader.retrieve_from_cache!('20071201-1234-345-2255/te??%st.jpeg')
+      }.should raise_error(CarrierWave::InvalidParameter)
+
+      @uploader.file.should be_nil
+      @uploader.filename.should be_nil
+      @uploader.cache_name.should be_nil
+    end
+  end
+
+  describe 'with an overridden, reversing, filename' do
+    before do
+      @uploader_class.class_eval do
+        def filename
+          super.reverse unless super.blank?
+        end
+      end
+    end
+
+    describe '#cache!' do
+
+      before do
+        CarrierWave.stub!(:generate_cache_id).and_return('20071201-1234-345-2255')
+      end
+
+      it "should set the filename to the file's reversed filename" do
+        @uploader.cache!(File.open(file_path('test.jpg')))
+        @uploader.filename.should == "gpj.tset"
+      end
+
+      it "should move it to the tmp dir with the filename unreversed" do
+        @uploader.cache!(File.open(file_path('test.jpg')))
+        @uploader.current_path.should == public_path('uploads/tmp/20071201-1234-345-2255/test.jpg')
+        @uploader.file.exists?.should be_true
+      end
+    end
+
+    describe '#retrieve_from_cache!' do
+      it "should set the path to the tmp dir" do
+        @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpg')
+        @uploader.current_path.should == public_path('uploads/tmp/20071201-1234-345-2255/test.jpg')
+      end
+
+      it "should set the filename to the reversed name of the file" do
+        @uploader.retrieve_from_cache!('20071201-1234-345-2255/test.jpg')
+        @uploader.filename.should == "gpj.tset"
+      end
+    end
+  end
+
+end