miloops-attachment_fu 3.2.5

data/test/backends/file_system_test.rb

@@ -0,0 +1,143 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+require 'digest/sha2'
+
+class FileSystemTest < Test::Unit::TestCase
+  include BaseAttachmentTests
+  attachment_model FileAttachment
+
+  def test_filesystem_size_for_file_attachment(klass = FileAttachment)
+    attachment_model klass
+    assert_created 1 do
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal attachment.size, File.open(attachment.full_filename).stat.size
+    end
+  end
+  
+  test_against_subclass :test_filesystem_size_for_file_attachment, FileAttachment
+
+  def test_should_not_overwrite_file_attachment(klass = FileAttachment)
+    attachment_model klass
+    assert_created 2 do
+      real = upload_file :filename => '/files/rails.png'
+      assert_valid real
+      assert !real.new_record?, real.errors.full_messages.join("\n")
+      assert !real.size.zero?
+      
+      fake = upload_file :filename => '/files/fake/rails.png'
+      assert_valid fake
+      assert !fake.size.zero?
+      
+      assert_not_equal File.open(real.full_filename).stat.size, File.open(fake.full_filename).stat.size
+    end
+  end
+  
+  test_against_subclass :test_should_not_overwrite_file_attachment, FileAttachment
+
+  def test_should_store_file_attachment_in_filesystem(klass = FileAttachment)
+    attachment_model klass
+    attachment = nil
+    assert_created do
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_valid attachment
+      assert File.exists?(attachment.full_filename), "#{attachment.full_filename} does not exist"    
+    end
+    attachment
+  end
+  
+  test_against_subclass :test_should_store_file_attachment_in_filesystem, FileAttachment
+  
+  def test_should_delete_old_file_when_updating(klass = FileAttachment)
+    attachment_model klass
+    attachment   = upload_file :filename => '/files/rails.png'
+    old_filename = attachment.full_filename
+    assert_not_created do
+      use_temp_file 'files/rails.png' do |file|
+        attachment.filename        = 'rails2.png'
+        attachment.temp_paths.unshift File.join(FIXTURE_PATH, file)
+        attachment.save!
+        assert  File.exists?(attachment.full_filename), "#{attachment.full_filename} does not exist"    
+        assert !File.exists?(old_filename),             "#{old_filename} still exists"
+      end
+    end
+  end
+  
+  test_against_subclass :test_should_delete_old_file_when_updating, FileAttachment
+  
+  def test_should_delete_old_file_when_renaming(klass = FileAttachment)
+    attachment_model klass
+    attachment   = upload_file :filename => '/files/rails.png'
+    old_filename = attachment.full_filename
+    assert_not_created do
+      attachment.filename        = 'rails2.png'
+      attachment.save
+      assert  File.exists?(attachment.full_filename), "#{attachment.full_filename} does not exist"    
+      assert !File.exists?(old_filename),             "#{old_filename} still exists"
+      assert !attachment.reload.size.zero?
+      assert_equal 'rails2.png', attachment.filename
+    end
+  end
+  
+  test_against_subclass :test_should_delete_old_file_when_renaming, FileAttachment
+  
+  def test_path_partitioning_works_on_integer_id(klass = FileAttachment)
+    attachment_model klass
+    
+    # Create a random attachment object, doesn't matter what.
+    attachment = upload_file :filename => '/files/rails.png'
+    old_id = attachment.id
+    attachment.id = 1
+    
+    begin
+      assert_equal ["0000", "0001", "bar.txt"], attachment.send(:partitioned_path, "bar.txt")
+    ensure
+      attachment.id = old_id
+    end
+  end
+  
+  test_against_subclass :test_path_partitioning_works_on_integer_id, FileAttachment
+  
+  def test_path_partitioning_with_string_id_works_by_generating_hash(klass = FileAttachmentWithStringId)
+    attachment_model klass
+    
+    # Create a random attachment object, doesn't matter what.
+    attachment = upload_file :filename => '/files/rails.png'
+    old_id = attachment.id
+    attachment.id = "hello world some long string"
+    hash = Digest::SHA512.hexdigest("hello world some long string")
+    
+    begin
+      assert_equal [
+          hash[0..31],
+          hash[32..63],
+          hash[64..95],
+          hash[96..127],
+          "bar.txt"
+        ], attachment.send(:partitioned_path, "bar.txt")
+    ensure
+      attachment.id = old_id
+    end
+  end
+  
+  test_against_subclass :test_path_partitioning_with_string_id_works_by_generating_hash, FileAttachmentWithStringId
+  
+  def test_path_partition_string_id_hashing_is_turned_off_if_id_is_uuid(klass = FileAttachmentWithUuid)
+    attachment_model klass
+    
+    # Create a random attachment object, doesn't matter what.
+    attachment = upload_file :filename => '/files/rails.png'
+    old_id = attachment.id
+    attachment.id = "0c0743b698483569dc65909a8cdb3bf9"
+    
+    begin
+      assert_equal [
+          "0c0743b698483569",
+          "dc65909a8cdb3bf9",
+          "bar.txt"
+        ], attachment.send(:partitioned_path, "bar.txt")
+    ensure
+      attachment.id = old_id
+    end
+  end
+  
+  test_against_subclass :test_path_partition_string_id_hashing_is_turned_off_if_id_is_uuid, FileAttachmentWithUuid
+end

data/test/backends/remote/cloudfiles_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'net/http'
+
+class CloudfilesTest < Test::Unit::TestCase
+  def self.test_CloudFiles?
+    true unless ENV["TEST_CLOUDFILES"] == "false"
+  end
+  
+  if test_CloudFiles? && File.exist?(File.join(File.dirname(__FILE__), '../../rackspace_cloudfiles.yml'))
+    include BaseAttachmentTests
+    attachment_model CloudFilesAttachment
+
+    def test_should_create_correct_container_name(klass = CloudFilesAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal attachment.cloudfiles_config[:container_name], attachment.container_name
+    end
+
+    test_against_subclass :test_should_create_correct_container_name, CloudFilesAttachment
+    
+    def test_should_create_default_path_prefix(klass = CloudFilesAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal File.join(attachment_model.table_name, attachment.attachment_path_id), attachment.base_path
+    end
+
+    test_against_subclass :test_should_create_default_path_prefix, CloudFilesAttachment
+    
+    def test_should_create_custom_path_prefix(klass = CloudFilesWithPathPrefixAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal File.join('some/custom/path/prefix', attachment.attachment_path_id), attachment.base_path
+    end
+
+    test_against_subclass :test_should_create_custom_path_prefix, CloudFilesWithPathPrefixAttachment
+    
+    
+    def test_should_create_valid_url(klass = CloudFilesAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_match(%r!http://cdn.cloudfiles.mosso.com/(.*?)/cloud_files_attachments/1/rails.png!, attachment.cloudfiles_url)
+    end
+    
+    test_against_subclass :test_should_create_valid_url, CloudFilesAttachment
+    
+    def test_should_save_attachment(klass = CloudFilesAttachment)
+      attachment_model klass
+      assert_created do
+        attachment = upload_file :filename => '/files/rails.png'
+        assert_valid attachment
+        assert attachment.image?
+        assert !attachment.size.zero?
+        assert_kind_of Net::HTTPOK, http_response_for(attachment.cloudfiles_url)
+      end
+    end
+
+    test_against_subclass :test_should_save_attachment, CloudFilesAttachment
+    
+    def test_should_delete_attachment_from_cloud_files_when_attachment_record_destroyed(klass = CloudFilesAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+
+      urls = [attachment.cloudfiles_url] + attachment.thumbnails.collect(&:cloudfiles_url)
+
+      urls.each {|url| assert_kind_of Net::HTTPOK, http_response_for(url) }
+      attachment.destroy
+      urls.each do |url|
+        begin
+          http_response_for(url)
+        rescue Net::HTTPForbidden, Net::HTTPNotFound
+          nil
+        end
+      end
+    end
+
+    test_against_subclass :test_should_delete_attachment_from_cloud_files_when_attachment_record_destroyed, CloudFilesAttachment
+    
+    
+    
+    protected
+      def http_response_for(url)
+        url = URI.parse(url)
+        Net::HTTP.start(url.host, url.port) {|http| http.request_head(url.path) }
+      end
+      
+      def s3_protocol
+        Technoweenie::AttachmentFu::Backends::S3Backend.protocol
+      end
+      
+      def s3_hostname
+        Technoweenie::AttachmentFu::Backends::S3Backend.hostname
+      end
+
+      def s3_port_string
+        Technoweenie::AttachmentFu::Backends::S3Backend.port_string
+      end
+  else
+    def test_flunk_s3
+      puts "s3 config file not loaded, tests not running"
+    end
+  end
+end

data/test/backends/remote/s3_test.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'net/http'
+
+class S3Test < Test::Unit::TestCase
+  def self.test_S3?
+    true unless ENV["TEST_S3"] == "false"
+  end
+  
+  if test_S3? && File.exist?(File.join(File.dirname(__FILE__), '../../amazon_s3.yml'))
+    include BaseAttachmentTests
+    attachment_model S3Attachment
+
+    def test_should_create_correct_bucket_name(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal attachment.s3_config[:bucket_name], attachment.bucket_name
+    end
+
+    test_against_subclass :test_should_create_correct_bucket_name, S3Attachment
+
+    def test_should_create_default_path_prefix(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal File.join(attachment_model.table_name, attachment.attachment_path_id), attachment.base_path
+    end
+
+    test_against_subclass :test_should_create_default_path_prefix, S3Attachment
+
+    def test_should_create_custom_path_prefix(klass = S3WithPathPrefixAttachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal File.join('some/custom/path/prefix', attachment.attachment_path_id), attachment.base_path
+    end
+
+    test_against_subclass :test_should_create_custom_path_prefix, S3WithPathPrefixAttachment
+
+    def test_should_create_valid_url(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_equal "#{s3_protocol}#{s3_hostname}#{s3_port_string}/#{attachment.bucket_name}/#{attachment.full_filename}", attachment.s3_url
+    end
+
+    test_against_subclass :test_should_create_valid_url, S3Attachment
+
+    def test_should_create_authenticated_url(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_match /^http.+AWSAccessKeyId.+Expires.+Signature.+/, attachment.authenticated_s3_url(:use_ssl => true)
+    end
+
+    test_against_subclass :test_should_create_authenticated_url, S3Attachment
+    
+    def test_should_create_authenticated_url_for_thumbnail(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+      ['large', :large].each do |thumbnail|
+        assert_match(
+          /^http.+rails_large\.png.+AWSAccessKeyId.+Expires.+Signature/, 
+          attachment.authenticated_s3_url(thumbnail), 
+          "authenticated_s3_url failed with #{thumbnail.class} parameter"
+        )
+      end
+    end
+
+    def test_should_save_attachment(klass = S3Attachment)
+      attachment_model klass
+      assert_created do
+        attachment = upload_file :filename => '/files/rails.png'
+        assert_valid attachment
+        assert attachment.image?
+        assert !attachment.size.zero?
+        assert_kind_of Net::HTTPOK, http_response_for(attachment.s3_url)
+      end
+    end
+
+    test_against_subclass :test_should_save_attachment, S3Attachment
+
+    def test_should_delete_attachment_from_s3_when_attachment_record_destroyed(klass = S3Attachment)
+      attachment_model klass
+      attachment = upload_file :filename => '/files/rails.png'
+
+      urls = [attachment.s3_url] + attachment.thumbnails.collect(&:s3_url)
+
+      urls.each {|url| assert_kind_of Net::HTTPOK, http_response_for(url) }
+      attachment.destroy
+      urls.each do |url|
+        begin
+          http_response_for(url)
+        rescue Net::HTTPForbidden, Net::HTTPNotFound
+          nil
+        end
+      end
+    end
+
+    test_against_subclass :test_should_delete_attachment_from_s3_when_attachment_record_destroyed, S3Attachment
+
+    protected
+      def http_response_for(url)
+        url = URI.parse(url)
+        Net::HTTP.start(url.host, url.port) {|http| http.request_head(url.path) }
+      end
+      
+      def s3_protocol
+        Technoweenie::AttachmentFu::Backends::S3Backend.protocol
+      end
+      
+      def s3_hostname
+        Technoweenie::AttachmentFu::Backends::S3Backend.hostname
+      end
+
+      def s3_port_string
+        Technoweenie::AttachmentFu::Backends::S3Backend.port_string
+      end
+  else
+    def test_flunk_s3
+      puts "s3 config file not loaded, tests not running"
+    end
+  end
+end

data/test/base_attachment_tests.rb

@@ -0,0 +1,77 @@
+module BaseAttachmentTests
+  def test_should_create_file_from_uploaded_file
+    assert_created do
+      attachment = upload_file :filename => '/files/foo.txt', :content_type => 'text/plain'
+      assert_valid attachment
+      assert !attachment.db_file.new_record? if attachment.respond_to?(:db_file)
+      assert !attachment.image?
+      assert !attachment.size.zero?
+      #assert_equal 3, attachment.size
+      assert_nil      attachment.width
+      assert_nil      attachment.height
+    end
+  end
+  
+  def test_should_create_file_from_merb_temp_file
+    assert_created do
+      attachment = upload_merb_file :filename => '/files/foo.txt', :content_type => 'text/plain'
+      assert_valid attachment
+      assert !attachment.db_file.new_record? if attachment.respond_to?(:db_file)
+      assert !attachment.image?
+      assert !attachment.size.zero?
+      #assert_equal 3, attachment.size
+      assert_nil      attachment.width
+      assert_nil      attachment.height
+    end
+  end
+  
+  def test_reassign_attribute_data
+    assert_created 1 do
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_valid attachment
+      assert attachment.size > 0, "no data was set"
+      
+      attachment.set_temp_data 'wtf'
+      assert attachment.save_attachment?
+      attachment.save!
+      
+      assert_equal 'wtf', attachment_model.find(attachment.id).send(:current_data)
+    end
+  end
+  
+  def test_no_reassign_attribute_data_on_nil
+    assert_created 1 do
+      attachment = upload_file :filename => '/files/rails.png'
+      assert_valid attachment
+      assert attachment.size > 0, "no data was set"
+      
+      attachment.set_temp_data nil
+      assert !attachment.save_attachment?
+    end
+  end
+  
+  def test_should_overwrite_old_contents_when_updating
+    attachment   = upload_file :filename => '/files/rails.png'
+    assert_not_created do # no new db_file records
+      use_temp_file 'files/rails.png' do |file|
+        attachment.filename = 'rails2.png'
+        attachment.temp_paths.unshift File.join(FIXTURE_PATH, file)
+        attachment.save!
+      end
+    end
+  end
+  
+  def test_should_save_without_updating_file
+    attachment = upload_file :filename => '/files/foo.txt'
+    assert_valid attachment
+    assert !attachment.save_attachment?
+    assert_nothing_raised { attachment.save! }
+  end
+  
+  def test_should_handle_nil_file_upload
+    attachment = attachment_model.create :uploaded_data => ''
+    assert_raise ActiveRecord::RecordInvalid do
+      attachment.save!
+    end
+  end
+end

data/test/basic_test.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class BasicTest < Test::Unit::TestCase
+  def test_should_set_default_min_size
+    assert_equal 1, Attachment.attachment_options[:min_size]
+  end
+
+  def test_should_set_default_max_size
+    assert_equal 1.megabyte, Attachment.attachment_options[:max_size]
+  end
+
+  def test_should_set_default_size
+    assert_equal (1..1.megabyte), Attachment.attachment_options[:size]
+  end
+
+  def test_should_set_default_thumbnails_option
+    assert_equal Hash.new, Attachment.attachment_options[:thumbnails]
+  end
+
+  def test_should_set_default_thumbnail_class
+    assert_equal Attachment, Attachment.attachment_options[:thumbnail_class]
+  end
+
+  def test_should_normalize_content_types_to_array
+    assert_equal %w(pdf), PdfAttachment.attachment_options[:content_type]
+    assert_equal %w(pdf doc txt), DocAttachment.attachment_options[:content_type]
+    assert_equal Technoweenie::AttachmentFu.content_types, ImageAttachment.attachment_options[:content_type]
+    assert_equal ['pdf'] + Technoweenie::AttachmentFu.content_types, ImageOrPdfAttachment.attachment_options[:content_type]
+  end
+
+  def test_should_sanitize_content_type
+    @attachment = Attachment.new :content_type => ' foo '
+    assert_equal 'foo', @attachment.content_type
+  end
+
+  def test_should_sanitize_filenames
+    @attachment = Attachment.new :filename => 'blah/foo.bar'
+    assert_equal 'foo.bar',    @attachment.filename
+
+    @attachment.filename = 'blah\\foo.bar'
+    assert_equal 'foo.bar',    @attachment.filename
+
+    @attachment.filename = 'f o!O-.bar'
+    assert_equal 'f_o_O-.bar', @attachment.filename
+
+    @attachment.filename = 'sheeps_says_bææ'
+    assert_equal 'sheeps_says_b__', @attachment.filename
+
+    @attachment.filename = nil
+    assert_nil @attachment.filename
+  end
+
+  def test_should_convert_thumbnail_name
+    @attachment = FileAttachment.new :filename => 'foo.bar'
+    assert_equal 'foo.bar',           @attachment.thumbnail_name_for(nil)
+    assert_equal 'foo.bar',           @attachment.thumbnail_name_for('')
+    assert_equal 'foo_blah.bar',      @attachment.thumbnail_name_for(:blah)
+    assert_equal 'foo_blah.blah.bar', @attachment.thumbnail_name_for('blah.blah')
+
+    @attachment.filename = 'foo.bar.baz'
+    assert_equal 'foo.bar_blah.baz', @attachment.thumbnail_name_for(:blah)
+  end
+
+  def test_should_require_valid_thumbnails_option
+    klass = Class.new(ActiveRecord::Base)
+    assert_raise ArgumentError do
+      klass.has_attachment :thumbnails => []
+    end
+  end
+
+  class ::ImageWithPolymorphicThumbsAttachment
+    cattr_accessor :thumbnail_creations
+
+    def create_or_update_thumbnail(path, thumb, *size)
+      @@thumbnail_creations[thumb] = size.size == 1 ? size.first : size
+    end
+
+    def self.reset_creations
+      @@thumbnail_creations = {}
+    end
+  end
+
+  def test_should_handle_polymorphic_thumbnails_option
+    assert_polymorphic_thumb_creation nil,
+      :thumb => [50, 50], :geometry => 'x50'
+    assert_polymorphic_thumb_creation 'Product',
+      :thumb => [50, 50], :geometry => 'x50', :large_thumb => '169x169!', :zoomed => '500x500>'
+    assert_polymorphic_thumb_creation 'Editorial',
+      :thumb => [50, 50], :geometry => 'x50', :fullsize => '150x100>'
+    assert_polymorphic_thumb_creation 'User',
+      :thumb => [50, 50], :geometry => 'x50', :avatar => '64x64!'
+  end
+
+  def test_should_compute_per_thumbnail_jpeg_quality
+    assert_jpeg_quality :thumb, 90
+    assert_jpeg_quality :avatar, 85
+    assert_jpeg_quality :large, 75
+    assert_jpeg_quality :large, 0x200 | 75, false
+    assert_jpeg_quality nil, 75
+  end
+
+private
+  def assert_jpeg_quality(thumbnail, quality, require_0_to_100 = true)
+    klass = ImageWithPerThumbJpegAttachment
+    w, h = if thumbnail
+      klass.attachment_options[:thumbnails][thumbnail].scan(/\d+/)
+    else
+      klass.attachment_options[:resize_to].scan(/\d+/)
+    end
+    attachment = klass.new(:thumbnail => thumbnail, :width => w, :height => h)
+    assert_equal quality, attachment.send(:get_jpeg_quality, require_0_to_100)
+  end
+
+  def assert_polymorphic_thumb_creation(parent, defs)
+    attachment_model ImageWithPolymorphicThumbsAttachment
+    attachment_model.reset_creations
+    attachment = upload_file :filename => '/files/rails.png', :imageable_type => parent.to_s.classify, :imageable_id => nil
+    assert_equal defs, attachment_model.thumbnail_creations
+  end
+end