attachment_saver 1.0.0

data/test/fixtures/broken.jpg

@@ -0,0 +1 @@
+test corrupt 'image'

data/test/fixtures/test.js

@@ -0,0 +1 @@
+This is a test file.

data/test/image_fixtures.rb

@@ -0,0 +1,69 @@
+class ImageFixtures
+  def self.fixture_path(filename)
+    File.join(File.dirname(__FILE__), 'fixtures', filename)
+  end
+  
+  def self.valid
+    { :path => fixture_path('test.jpg'),
+      :content_type => 'image/jpeg',
+      :original_filename => 'test.jpg',
+      :width => 448,
+      :height => 600,
+      :expected_content_type => 'image/jpeg',
+      :expected_extension => 'jpg' }
+  end
+  
+  def self.wrong_extension
+    { :path => fixture_path('wrongextension.png'),
+      :content_type => 'image/png',
+      :original_filename => 'wrongextension.png',
+      :width => 448,
+      :height => 600,
+      :expected_content_type => 'image/jpeg',
+      :expected_extension => 'jpg' }
+  end
+  
+  def self.no_extension
+    { :path => fixture_path('noextension'),
+      :content_type => 'application/octet-stream',
+      :original_filename => 'noextension',
+      :width => 448,
+      :height => 600,
+      :expected_content_type => 'image/jpeg',
+      :expected_extension => 'jpg' }
+  end
+  
+  def self.empty_extension
+    { :path => fixture_path('emptyextension.'),
+      :content_type => 'application/octet-stream',
+      :original_filename => 'emptyextension.',
+      :width => 448,
+      :height => 600,
+      :expected_content_type => 'image/jpeg',
+      :expected_extension => 'jpg' }
+  end
+  
+  def self.corrupt
+    { :path => fixture_path('broken.jpg'),
+      :content_type => 'image/jpeg',
+      :original_filename => 'broken.jpg',
+      :expected_content_type => 'image/jpeg',
+      :expected_extension => 'jpg' }
+  end
+  
+  def self.non_image_file
+    { :path => fixture_path('test.js'),
+      :content_type => 'application/javascript',
+      :original_filename => 'test.js',
+      :expected_content_type => 'application/javascript',
+      :expected_extension => 'js' }
+  end
+  
+  def self.all_readable
+    [valid, wrong_extension, no_extension, empty_extension]
+  end
+  
+  def self.all_unreadable
+    [corrupt, non_image_file]
+  end
+end

data/test/image_operations.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_fixtures'))
+
+class ImageOperations
+  def self.original_image
+    { :path => ImageFixtures::fixture_path('test.jpg'),
+      :content_type => 'image/jpeg',
+      :original_filename => 'test.jpg',
+      :width => 448,
+      :height => 600 }
+  end
+  
+  def self.resize_operations
+    {
+      :squish1 =>         [:squish, 100, 50],
+      :squish2 =>         [:squish, 10, 50],
+      
+      :scaleby1 =>        [:scale_by, 0.125, 0.125],
+      :scaleby2 =>        [:scale_by, 0.5, 1.0],
+      
+      :scaletosize1 =>    [:scale_to_fit, 200, 300],
+      :scaletosize2 =>    [:scale_to_fit, 720, 900],
+      :shrinktosize1 =>   [:shrink_to_fit, 200, 300],
+      :shrinktosize2 =>   [:shrink_to_fit, 720, 900],
+      :expandtosize1 =>   [:expand_to_fit, 200, 300],
+      :expandtosize2 =>   [:expand_to_fit, 720, 900],
+      :expandtosize3 =>   [:expand_to_fit, 200, 900],
+      :expandtosize4 =>   [:expand_to_fit, 720, 300],
+      
+      :scaletowidth1 =>   [:scale_to_fit, 200, nil],
+      :scaletowidth2 =>   [:scale_to_fit, 720, nil],
+      :shrinktowidth1 =>  [:shrink_to_fit, 200, nil],
+      :shrinktowidth2 =>  [:shrink_to_fit, 720, nil],
+      
+      :scaletoheight1 =>  [:scale_to_fit, nil, 300],
+      :scaletoheight2 =>  [:scale_to_fit, nil, 900],
+      :shrinktoheight1 => [:shrink_to_fit, nil, 300],
+      :shrinktoheight2 => [:shrink_to_fit, nil, 900],
+      
+      :scaletocover1 =>   [:scale_to_cover, 200, 300],
+      :scaletocover2 =>   [:scale_to_cover, 720, 900],
+      
+      :coverandcrop1 =>   [:cover_and_crop, 200, 300],
+      :coverandcrop2 =>   [:cover_and_crop, 720, 900],
+    }
+  end
+  
+  def self.expected_results
+    {
+      :squish1 =>         [100, 50],
+      :squish2 =>         [10, 50],
+      
+      :scaleby1 =>        [56, 75],
+      :scaleby2 =>        [224, 600],
+      
+      :scaletosize1 =>    [200, 200*600/448],
+      :scaletosize2 =>    [900*448/600, 900],
+      :shrinktosize1 =>   [200, 200*600/448],
+      :shrinktosize2 =>   [448, 600],
+      :expandtosize1 =>   [448, 600],
+      :expandtosize2 =>   [900*448/600, 900],
+      :expandtosize3 =>   [448, 600],
+      :expandtosize4 =>   [448, 600],
+      
+      :scaletowidth1 =>   [200, 200*600/448],
+      :scaletowidth2 =>   [720, 720*600/448],
+      :shrinktowidth1 =>  [200, 200*600/448],
+      :shrinktowidth2 =>  [448, 600],
+      
+      :scaletoheight1 =>  [300*448/600, 300],
+      :scaletoheight2 =>  [900*448/600, 900],
+      :shrinktoheight1 => [300*448/600, 300],
+      :shrinktoheight2 => [448, 600],
+      
+      :scaletocover1 =>   [300*448/600, 300],
+      :scaletocover2 =>   [720, 720*600/448],
+      
+      :coverandcrop1 =>   [200, 300],
+      :coverandcrop2 =>   [720, 900],
+    }
+  end
+  
+  def self.geometry_strings
+    {
+      '110x50' =>       [:scale_to_fit, 110, 50],
+      '209' =>          [:scale_to_fit, 209, 209],
+      '91x' =>          [:scale_to_fit, 91, nil],
+      'x48' =>          [:scale_to_fit, nil, 48],
+      
+      '110x50!' =>      [:squish, 110, 50],
+      '209!' =>         [:squish, 209, 209],
+      '91x!' =>         [:scale_to_fit, 91, nil], # ! flag has no meaning/effect here
+      'x48!' =>         [:scale_to_fit, nil, 48], # same
+      
+      '110.5x50.2%' =>  [:scale_by, 1.105, 0.502],
+      '209.84%' =>      [:scale_by, 2.0984, 2.0984],
+      '91.0x%' =>       [:scale_by, 0.910, 0.910],
+      'x48.%' =>        [:scale_by, 0.480, 0.480],
+      
+      '110x50>' =>      [:shrink_to_fit, 110, 50],
+      '209>' =>         [:shrink_to_fit, 209, 209],
+      '91x>' =>         [:shrink_to_fit, 91, nil],
+      'x48>' =>         [:shrink_to_fit, nil, 48],
+      
+      '110x50<' =>      [:expand_to_fit, 110, 50],
+      '209<' =>         [:expand_to_fit, 209, 209],
+      '91x<' =>         [:expand_to_fit, 91, nil],
+      'x48<' =>         [:expand_to_fit, nil, 48],
+      
+      '110x50#' =>      [:cover_and_crop, 110, 50],
+      '91x#' =>         [:cover_and_crop, 91, nil],
+      'x48#' =>         [:cover_and_crop, nil, 48],
+    }
+  end
+end

data/test/image_processor_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require 'mocha'
+require 'processors/image'
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_operations'))
+
+class ImageProcessorTest < Test::Unit::TestCase
+  class SomeModel
+    include AttachmentSaver::Processors::Image
+    
+    cattr_accessor :attachment_options
+    attr_accessor :content_type
+    
+    def initialize(content_type)
+      self.content_type = content_type
+    end
+  end
+  
+  def test_image?
+    [nil, '', '/', 'foo', 'foo/' '/bar', 'text/plain', 'x-image/invalid', 'image-x/invalid'].each do |mime|
+      assert_equal false, SomeModel.new(mime).image?
+    end
+    
+    ['image/jpeg', 'image/png', 'image/gif'].each do |mime|
+      assert_equal true, SomeModel.new(mime).image?
+    end
+  end
+  
+  def test_process_attachment?
+    SomeModel.attachment_options = {}
+    assert_equal false, SomeModel.new('text/plain').process_attachment?
+    assert_equal false, SomeModel.new('image/jpeg').process_attachment?
+    
+    SomeModel.attachment_options = {:formats => {'thumb' => '50x50'}}
+    assert_equal false, SomeModel.new('text/plain').process_attachment?
+    assert_equal true, SomeModel.new('image/jpeg').process_attachment?
+  end
+  
+  def test_before_validate_attachment
+    model_without_upload = SomeModel.new('application/octet-stream') # note the content type doesn't have to be an image for examine_attachment to be called, since examine_attachment is supposed to fix up incorrect client-supplied content-types
+    model_without_upload.expects(:uploaded_file).times(1).returns(nil)
+    model_without_upload.expects(:examine_attachment).times(0)
+    model_without_upload.before_validate_attachment
+    
+    model_with_upload = SomeModel.new('application/octet-stream')
+    model_with_upload.expects(:uploaded_file).times(1).returns('dummy')
+    model_with_upload.expects(:examine_attachment).times(1)
+    model_with_upload.before_validate_attachment
+    
+    model_with_non_image_upload = SomeModel.new('text/plain')
+    model_with_non_image_upload.expects(:uploaded_file).times(1).returns('dummy')
+    model_with_non_image_upload.expects(:examine_attachment).times(1).raises(ImageProcessorError)
+    model_with_non_image_upload.before_validate_attachment
+    assert_equal 'text/plain', model_with_non_image_upload.content_type
+    
+    model_with_mislabelled_non_image_upload = SomeModel.new('image/png')
+    model_with_mislabelled_non_image_upload.expects(:uploaded_file).times(1).returns('dummy')
+    model_with_mislabelled_non_image_upload.expects(:examine_attachment).times(1).raises(ImageProcessorError)
+    model_with_mislabelled_non_image_upload.before_validate_attachment
+    assert_equal 'application/octet-stream', model_with_mislabelled_non_image_upload.content_type
+  end
+  
+  def test_from_geometry_string
+    ImageOperations::geometry_strings.each do |geometry, expected_result|
+      assert_equal expected_result, AttachmentSaver::Processors::Image.from_geometry_string(geometry), "geometry parse of #{geometry} produced incorrect results"
+    end
+  end
+end

data/test/image_processor_test_common.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require 'attachment_saver'
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_fixtures'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_operations'))
+
+module ImageProcessorTestModel
+  attr_accessor :content_type, :original_filename, :width, :height
+  
+  def self.included(base)
+    base.cattr_accessor :attachment_options
+  end
+  
+  def initialize(uploaded_data)
+    self.uploaded_data = uploaded_data
+  end
+  
+  def new_record?
+    true
+  end
+  
+  def build_derived(attrs)
+    @derived_attributes ||= {}
+    raise "already have a derived image named #{attrs[:format_name]}" if @derived_attributes[attrs[:format_name].to_s]
+    @derived_attributes[attrs[:format_name].to_s] = attrs # and it would build a record, not just save the attributes
+  end
+  
+  def find_derived(format_name)
+    @derived_attributes[format_name.to_s]
+  end
+end
+
+module ImageProcessorTests
+  def test_attributes_from_valid
+    processor_model.attachment_options = {}
+    ImageFixtures.all_readable.each do |fixture|
+      model = processor_model.new(File.open(fixture[:path], 'rb'))
+      model.content_type = fixture[:content_type]
+      model.original_filename = fixture[:original_filename]
+      model.examine_attachment
+      assert_equal fixture[:expected_content_type], model.content_type
+      assert_equal fixture[:width], model.width
+      assert_equal fixture[:height], model.height
+      assert_equal "#{fixture[:width]}x#{fixture[:height]}", model.image_size
+      assert_equal fixture[:expected_extension], model.file_extension
+    end
+  end
+  
+  def test_attributes_from_invalid
+    processor_model.attachment_options = {}
+    ImageFixtures.all_unreadable.each do |fixture|
+      model = processor_model.new(File.open(fixture[:path], 'rb'))
+      model.content_type = fixture[:content_type]
+      assert_raises(processor_exception) { model.examine_attachment }
+      assert_equal fixture[:expected_content_type], model.content_type
+      assert_equal nil, model.width
+      assert_equal nil, model.height
+      assert_equal nil, model.image_size
+      assert_equal 'bin', model.file_extension
+      model.original_filename = fixture[:original_filename]
+      assert_equal fixture[:expected_extension], model.file_extension
+    end
+  end
+  
+  def test_derived_attributes_from_valid
+    processor_model.attachment_options = {:formats => ImageOperations.resize_operations}
+
+    fixture = ImageOperations.original_image
+    model = processor_model.new(File.open(fixture[:path], 'rb'))
+    model.content_type = fixture[:content_type]
+    model.original_filename = fixture[:original_filename]
+    model.process_attachment(model.uploaded_file_path)
+    
+    ImageOperations.expected_results.each do |format_name, size|
+      derived = model.find_derived(format_name)
+      assert !derived.nil?, "no derived image named #{format_name} generated"
+      assert_equal size.first, derived[:width], "#{format_name} width incorrect"
+      assert_equal size.last, derived[:height], "#{format_name} height incorrect"
+      assert_equal model.file_extension, derived[:file_extension], "#{format_name} file_extension incorrect"
+    end
+  end
+end

data/test/image_science_processor_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_processor_test_common'))
+require 'processors/image_science'
+
+class ImageScienceProcessorTest < Test::Unit::TestCase
+  class ImageScienceTestModel
+    include AttachmentSaver::InstanceMethods
+    include AttachmentSaver::Processors::ImageScience
+    include ImageProcessorTestModel
+  end
+  
+  def processor_model
+    ImageScienceTestModel
+  end
+  
+  def processor_exception
+    ImageScienceProcessorError
+  end
+
+  include ImageProcessorTests
+end

data/test/in_column_datastore_test.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require 'mocha'
+require 'datastores/in_column'
+
+class InColumnDatastoreTest < Test::Unit::TestCase
+  attr_accessor :data, :original_filename, :content_type
+  
+  DEFAULT_ATTACHMENT_OPTIONS = {}
+  
+  def self.attachment_options
+    @@attachment_options ||= DEFAULT_ATTACHMENT_OPTIONS
+  end
+
+  include AttachmentSaver::DataStores::InColumn
+  
+  def uploaded_data
+    if @uploaded_data.nil?
+      if @uploaded_file.nil?
+        nil
+      else
+        @uploaded_file.rewind
+        @uploaded_file.read
+      end
+    else
+      @uploaded_data
+    end
+  end
+    
+  def setup
+    @test_filename = File.join(RAILS_ROOT, "tmp", "test#{$$}.dat")
+    @uploaded_data = nil
+    @uploaded_file = nil
+    @saved_to = nil
+    self.data = nil
+    self.original_filename = 'myfile.dat'
+    self.content_type = 'application/octet-stream'
+  end
+  
+  def random_data(length = nil)
+    length = 512 + rand(2048) if length.nil?
+    Array.new(length).collect {rand(256)} .pack('C*')
+  end
+  
+  def save_attachment_test(expected_data)
+    expects(:process_attachment?).times(1).returns(false)
+    save_attachment
+    
+    assert !data.nil? && data != "", "no data saved"
+    data.force_encoding("ascii-8bit") if data.respond_to?(:force_encoding)
+    assert expected_data == data, "data stored doesn't match"
+  end
+
+
+  def test_save_attachment_for_data
+    @uploaded_data = data = random_data
+    @save_upload = true
+    save_attachment_test(data)
+  end
+  
+  def test_save_attachment_for_file
+    data = random_data
+    FileUtils.mkdir_p(File.dirname(@test_filename))
+    File.open(@test_filename + '.src_file', 'wb+') do |file|
+      file.write(data)
+      @uploaded_file = file
+      @save_upload = true
+      save_attachment_test(data)
+    end
+  end
+  
+  def test_save_attachment_for_tempfile
+    data = random_data
+    FileUtils.mkdir_p(File.dirname(@test_filename))
+    Tempfile.open('src_file', File.dirname(@test_filename)) do |file|
+      file.write(data)
+      @uploaded_file = file
+      @save_upload = true
+      save_attachment_test(data)
+    end
+  end
+  
+  
+  def test_save_attachment_calls_processing
+    @uploaded_data = expected_data = random_data
+    @save_upload = true
+    expects(:process_attachment?).times(1).returns(true)
+    expects(:process_attachment_with_wrapping).times(1).returns do |filename|
+      assert expected_data == File.read(filename)
+    end
+    
+    save_attachment
+    
+    assert expected_data == data
+  end
+  
+  
+  def test_save_attachment_without_upload
+    expects(:process_attachment?).times(0)
+    expects(:process_attachment).times(0)
+    save_attachment
+    assert_equal nil, data
+  end
+  
+  
+  def test_in_storage?
+    @uploaded_data = random_data
+    @save_upload = true
+    expects(:process_attachment?).times(1).returns(false)
+    save_attachment
+    
+    assert_equal true, in_storage?
+    self.data = nil
+    assert_equal false, in_storage?
+  end
+end