robinboening-fleximage 1.0.4

data/test/unit/file_upload_from_url_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageFileUploadFromUrlTest < Test::Unit::TestCase
+  def test_should_be_valid_with_image_from_url
+    p = PhotoBare.new(:image_file_url => files(:web_photo))
+    assert p.save, 'Record expected to be valid after upload via URL'
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_be_invalid_with_nonimage_from_url
+    p = PhotoBare.new(:image_file_url => 'http://www.google.com/')
+    assert !p.save, 'Record expected to be invalid after upload via URL'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file_url)
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_be_invalid_with_invalid_url
+    p = PhotoBare.new(:image_file_url => 'foo')
+    assert !p.save, 'Record expected to be invalid after upload via URL'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file_url)
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_have_an_original_filename
+    p = PhotoFile.new(:image_file_url => files(:web_photo))
+    assert_equal p.image_filename, files(:web_photo)
+  rescue SocketError
+    print '!'
+  end
+end

data/test/unit/file_upload_to_db_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageFileUploadToDbTest < Test::Unit::TestCase
+  def test_should_be_valid_with_image
+    p = PhotoDb.new(:image_file => files(:photo))
+    assert p.save, 'Record expected to be allowed to save'
+    
+    p = PhotoDb.find(p.id)
+    assert_kind_of Magick::Image, p.load_image
+    assert p.image_file_data.size > 0
+  end
+  
+  def test_should_require_an_image
+    p = PhotoDb.new
+    assert !p.save, 'Record expected to not be allowed to save'
+    assert_equal 1, p.errors.size
+    assert_equal 'is required', p.errors.on(:image_file)
+  end
+  
+  def test_should_require_an_valid_image
+    p = PhotoDb.new(:image_file => files(:not_a_photo))
+    assert !p.save, 'Record expected to not be allowed to save'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file)
+  end
+  
+  def test_should_retrieve_a_stored_image
+    id = PhotoDb.create(:image_file => files(:photo)).id
+    p = PhotoDb.find(id)
+    assert_kind_of Magick::Image, p.load_image
+    assert_equal 768,  p.load_image.columns
+    assert_equal 1024, p.load_image.rows
+  end
+  
+  def test_should_delete_an_image
+    id = PhotoDb.create(:image_file => files(:photo)).id
+    photo = PhotoDb.find(id)
+    photo.destroy
+    assert_nil PhotoDb.find_by_id(id)
+  end
+end

data/test/unit/has_store_test.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageHasStoreTest < Test::Unit::TestCase
+end

data/test/unit/i18n_messages_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+
+class I18nMessagesTest < Test::Unit::TestCase
+  def test_should_have_default_message
+    p = PhotoBare.new
+    p.save
+    assert_equal "is required", p.errors["image_file"]
+    
+    p = PhotoBare.new(:image_file => files(:not_a_photo))
+    p.save
+    assert_equal "was not a readable image", p.errors["image_file"]
+    
+    p = PhotoBare.new(:image_file => files(:i1x1))
+    p.save
+    assert_equal "is too small (Minimum: 2x2)", p.errors["image_file"]
+  end
+  
+  def test_should_have_german_message
+    I18n.locale = "de"
+    p = PhotoBare.new
+    p.save
+    assert_equal "ist erforderlich", p.errors["image_file"]
+    
+    p = PhotoBare.new(:image_file => files(:not_a_photo))
+    p.save
+    assert_equal "war nicht lesbar", p.errors["image_file"]
+    
+    p = PhotoBare.new(:image_file => files(:i1x1))
+    p.save
+    assert_equal "ist zu klein (Minimalgröße: 2x2)", p.errors["image_file"]
+  ensure
+    I18n.locale = "en"
+  end
+  
+  def test_should_have_model_specific_message
+    p = PhotoCustomError.new
+    assert !p.save
+    assert_equal "needs to be attached", p.errors["image_file"]
+    
+    p = PhotoCustomError.new(:image_file => files(:not_a_photo))
+    p.save
+    assert_equal "seems to be broken", p.errors["image_file"]
+    
+    p = PhotoCustomError.new(:image_file => files(:i1x1))
+    assert !p.save
+    assert_equal "must be bigger (min. size: 2x2)", p.errors["image_file"]
+  end
+end

data/test/unit/image_directory_option_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageImageDirectoryOptionTest < Test::Unit::TestCase
+  def test_should_store_in_default_image_directory
+    PhotoBare.use_creation_date_based_directories = true
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_match %r{public/uploads/\d+/\d+/\d+/\d+}, p.file_path
+    assert File.exists?(p.file_path)
+  end
+  
+  def test_should_set_image_directory
+    PhotoBare.use_creation_date_based_directories = true
+    PhotoBare.image_directory = 'public/uploads/foo'
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_match %r{public/uploads/foo/\d+/\d+/\d+/\d+}, p.file_path
+    assert File.exists?(p.file_path)
+  ensure
+    PhotoBare.image_directory = 'public/uploads'
+  end
+end

data/test/unit/image_proxy_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageImageProxyTest < Test::Unit::TestCase
+  def test_should_have_a_width
+    p = PhotoBare.create(:image_file => files(:photo))
+    p.operate do |image|
+      assert_equal 768, image.width
+    end
+  end
+  
+  def test_should_have_a_height
+    p = PhotoBare.create(:image_file => files(:photo))
+    p.operate do |image|
+      assert_equal 1024, image.height
+    end
+  end
+end

data/test/unit/image_storage_format_option_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageImageStorageOptionTest < Test::Unit::TestCase
+  def test_should_have_default_storage_format_png
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_match %r{\d+\.png$}, p.file_path
+    assert_equal 'PNG', p.load_image.format
+  end
+  
+  def test_should_set_image_storage_format_to_jpg
+    PhotoBare.image_storage_format = :jpg
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_match %r{\d+\.jpg$}, p.file_path
+    assert_equal 'JPG', p.load_image.format
+  ensure
+    PhotoBare.image_storage_format = :png
+  end
+  
+  def test_should_have_default_storage_format_png_in_db
+    p = PhotoDb.create(:image_file => files(:photo))
+    assert_equal 'PNG', p.load_image.format
+  end
+  
+  def test_should_set_image_storage_format_to_jpg_in_db
+    PhotoDb.image_storage_format = :jpg
+    p = PhotoDb.create(:image_file => files(:photo))
+    assert_equal 'JPG', p.load_image.format
+  ensure
+    PhotoDb.image_storage_format = :png
+  end
+end

data/test/unit/magic_columns_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageMagicColumnsTest < Test::Unit::TestCase
+  def test_should_save_data_in_magic_columns_from_local
+    p = PhotoFile.create(:image_file => files(:photo))
+    assert_equal 'photo.jpg', p.image_filename
+    assert_equal 1024,  p.image_height
+    assert_equal 768,   p.image_width
+    assert_equal 'JPEG', p.image_format
+    assert_equal 'jpg', p.extension
+  end
+  
+  def test_should_save_data_in_magic_columns_from_url
+    p = PhotoFile.create(:image_file_url => files(:web_photo))
+    assert_equal files(:web_photo), p.image_filename
+    assert_equal 110,   p.image_height
+    assert_equal 276,   p.image_width
+    assert_equal 'GIF', p.image_format
+    assert_equal 'gif', p.extension
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_delete_magic_columns_when_image_is_deleted
+    p = PhotoFile.new(:image_file => files(:photo))
+    p.save
+    
+    p = PhotoFile.find(p.id)
+    p.delete_image_file.save
+    
+    assert_nil p.image_width
+    assert_nil p.image_height
+  end
+end

data/test/unit/minimum_image_size_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+
+class BigPhoto < ActiveRecord::Base
+  set_table_name :photo_dbs
+  acts_as_fleximage do
+    validates_image_size '80x60'
+  end
+end
+
+class WidePhoto < ActiveRecord::Base
+  set_table_name :photo_dbs
+  acts_as_fleximage do
+    validates_image_size '80x0'
+  end
+end
+
+class HighPhoto < ActiveRecord::Base
+  set_table_name :photo_dbs
+  acts_as_fleximage do
+    validates_image_size '0x60'
+  end
+end
+
+class MinimumImageSizeTest < Test::Unit::TestCase
+  def test_should_not_save_small_image
+    p = BigPhoto.new(:image_file => files(:i1x1))
+    assert !p.save
+    assert p.errors["image_file"].match(/is too small/)
+  end
+  
+  def test_should_save_big_image
+    p = BigPhoto.new(:image_file => files(:i100x100))
+    assert p.save
+  end
+  
+  def test_should_only_save_wide
+    p = WidePhoto.new(:image_file => files(:i1x100))
+    assert !p.save
+    p = WidePhoto.new(:image_file => files(:i100x1))
+    assert p.save
+  end
+  
+  def test_should_only_save_high
+    p = HighPhoto.new(:image_file => files(:i100x1))
+    assert !p.save
+    p = HighPhoto.new(:image_file => files(:i1x100))
+    assert p.save
+  end
+  
+  def test_should_include_minimum_dimensions_in_message
+    p = BigPhoto.new(:image_file => files(:i1x1))
+    p.save
+    assert_equal "is too small (Minimum: 80x60)", p.errors["image_file"]
+  end
+end

data/test/unit/operator_base_test.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageOperatorBaseTest < Test::Unit::TestCase
+  def setup
+    @photo  = PhotoBare.create(:image_file => files(:photo))
+    proxy   = Fleximage::ImageProxy.new(@photo.load_image, @photo)
+    @op     = Fleximage::Operator::Base.new(proxy, @photo.load_image, @photo)
+    
+    @other_img = Magick::Image.read(@photo.file_path).first
+  end
+  
+  def test_should_raise_operation_not_implemented_exception
+    assert_raise(Fleximage::Operator::OperationNotImplemented) do
+      @photo.operate { |p| p.base }
+    end
+  end
+  
+  
+  # size_to_xy
+  
+  def test_should_parse_size_string_to_x_and_y
+    assert_equal [1,2],     @op.size_to_xy('1x2')
+    assert_equal [640,480], @op.size_to_xy('640x480')
+  end
+  
+  def test_should_parse_size_array_to_x_and_y
+    assert_equal [1,2],     @op.size_to_xy([1,2])
+    assert_equal [640,480], @op.size_to_xy([640,480])
+  end
+  
+  def test_should_parse_single_size_array_to_square_x_and_y
+    assert_equal [2,2],     @op.size_to_xy(2)
+    assert_equal [2,2],     @op.size_to_xy('2')
+    assert_equal [480,480], @op.size_to_xy(480)
+    assert_equal [480,480], @op.size_to_xy('480')
+  end
+  
+  
+  # scale
+  
+  def test_should_scale_the_main_image_and_keep_its_aspect_ratio
+    img = @op.scale(400)
+    assert_equal 400, img.rows
+    assert_equal 300, img.columns
+    assert_equal 400, @photo.load_image.rows
+    assert_equal 300, @photo.load_image.columns
+  end
+  
+  def test_should_scale_a_different_image_and_keep_its_aspect_ratio
+    @op.scale(400, @other_img)
+    assert_equal 400, @other_img.rows
+    assert_equal 300, @other_img.columns
+    assert_equal 1024, @photo.load_image.rows
+    assert_equal 768, @photo.load_image.columns
+  end
+  
+  
+  # scale and crop
+  
+  def test_should_scale_and_crop_the_main_image
+    img = @op.scale_and_crop(400)
+    assert_equal 400, img.rows
+    assert_equal 400, img.columns
+    assert_equal 400, @photo.load_image.rows
+    assert_equal 400, @photo.load_image.columns
+  end
+  
+  def test_should_scale_and_crop_a_different_image
+    @op.scale_and_crop(400, @other_img)
+    assert_equal 400, @other_img.rows
+    assert_equal 400, @other_img.columns
+    assert_equal 1024, @photo.load_image.rows
+    assert_equal 768, @photo.load_image.columns
+  end
+  
+  
+  # stretch
+  
+  def test_should_stretch_the_main_image
+    img = @op.stretch(400)
+    assert_equal 400, img.rows
+    assert_equal 400, img.columns
+    assert_equal 400, @photo.load_image.rows
+    assert_equal 400, @photo.load_image.columns
+  end
+  
+  def test_should_stretch_a_different_image
+    @op.stretch(400, @other_img)
+    assert_equal 400, @other_img.rows
+    assert_equal 400, @other_img.columns
+    assert_equal 1024, @photo.load_image.rows
+    assert_equal 768, @photo.load_image.columns
+  end
+  
+  
+  def test_should_convert_symbol_to_rmagick_blending_mode
+    assert_equal Magick::MultiplyCompositeOp,   @op.symbol_to_blending_mode(:multiply)
+    assert_equal Magick::OverCompositeOp,       @op.symbol_to_blending_mode(:over)
+    assert_equal Magick::ScreenCompositeOp,     @op.symbol_to_blending_mode(:screen)
+    assert_equal Magick::CopyBlackCompositeOp,  @op.symbol_to_blending_mode(:copy_black)
+  end
+  
+  def test_should_raise_argument_error_when_no_blend_mode_found
+    assert_raise(ArgumentError) do
+      @op.symbol_to_blending_mode(:foobar)
+    end
+  end
+  
+  
+  # gravity lookup
+  
+  def test_should_lookup_correct_gravity
+    assert_equal Magick::CenterGravity,     @op.symbol_to_gravity(:center)
+    assert_equal Magick::NorthGravity,      @op.symbol_to_gravity(:top)
+    assert_equal Magick::SouthWestGravity,  @op.symbol_to_gravity(:bottom_left)
+  end
+  
+  def test_should_raise_error_with_a_bad_gravity
+    assert_raise(ArgumentError) do
+      @op.symbol_to_gravity(:foo)
+    end
+  end
+  
+end

data/test/unit/operator_resize_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageOperatorResizeTest < Test::Unit::TestCase
+  def setup
+    @photo  = PhotoBare.create(:image_file => files(:photo))
+    proxy   = Fleximage::ImageProxy.new(@photo.load_image, @photo)
+    @op     = Fleximage::Operator::Base.new(proxy, @photo.load_image, @photo)
+    
+    @other_img = Magick::Image.read(@photo.file_path).first
+  end
+  
+  def test_should_resize
+    @photo.operate { |p| p.resize '300x400' }
+    assert_equal 400, @photo.load_image.rows
+    assert_equal 300, @photo.load_image.columns
+  end
+  
+end