zena 0.16.9 → 1.0.0.beta1

data/test/unit/exif_data_test.rb

@@ -51,7 +51,7 @@ class ExifDataTest < Test::Unit::TestCase
 
   def test_to_json_should_ignore_symbols
     e = ExifData.new("Make" => "SONY", "DateTime" => "1998:10:01 10:15:30")
-    assert_equal '{"Make":"SONY","DateTime":"1998:10:01 10:15:30"}', e.to_json
+    assert_equal '{"data":{"Make":"SONY","DateTime":"1998:10:01 10:15:30"},"json_class":"ExifData"}', e.to_json
   end
 
   def test_gps_longitude

data/test/unit/iformat_test.rb

@@ -16,7 +16,7 @@ class IformatTest < Zena::Unit::TestCase
     login(:lion)
     fmt = Iformat['med']
     assert_not_equal Zena::Use::ImageBuilder::DEFAULT_FORMATS['med'], fmt
-    assert_equal ({:name => 'med', :width=>300, :height=>200, :gravity=>Magick::CenterGravity, :size=>:limit, :hash_id => 389519063846, :popup => {:show=> %w{navigation v_title v_summary}, :name=>'std', :options=>{'v_title'=>'link'}}}), fmt
+    assert_equal ({:name => 'med', :width=>300, :height=>200, :gravity=>Magick::CenterGravity, :size=>:limit, :hash_id => 389519063846, :popup => {:show=> %w{navigation title summary}, :name=>'std', :options=>{'title'=>'link'}}}), fmt
   end
 
   def test_format_hash_id
@@ -120,12 +120,12 @@ class IformatTest < Zena::Unit::TestCase
   def test_update_expire_cache_and_formated_images
     login(:lion)
     bird = secure(Node) { nodes(:bird_jpg) }
-    assert bird.c_file(Iformat['med']) # force creation of bird_med.jpg
-    assert File.exist?(bird.version.content.filepath(Iformat['med']))
+    assert bird.file(Iformat['med']) # force creation of bird_med.jpg
+    assert File.exist?(bird.filepath(Iformat['med']))
     # Update format
     assert Iformat.update(iformats_id(:med), :width => 350)
-    assert !File.exist?(bird.version.content.filepath(Iformat['med'])), "Calculated image removed"
-    assert File.exist?(bird.version.content.filepath), "Original not removed"
+    assert !File.exist?(bird.filepath(Iformat['med'])), "Calculated image removed"
+    assert File.exist?(bird.filepath), "Original not removed"
   end
 
   def test_create_first
@@ -200,19 +200,19 @@ class IformatTest < Zena::Unit::TestCase
       end
 
       should 'use default fields and navigation' do
-        assert_equal({:show=>%w{navigation v_title v_summary}, :name=>"pop", :options=>{'v_title' => 'link'}}, @imf[:popup])
+        assert_equal({:show=>%w{navigation title summary}, :name=>"pop", :options=>{'title' => 'link'}}, @imf[:popup])
       end
     end
 
     context 'defined with name and json' do
       setup do
         Iformat.create(:name  => 'header', :height=>'34', :width => '500', :size => 'force',
-                       :popup => 'pop {"v_title":"link", "a":true}')
+                       :popup => 'pop {"title":"link", "a":true}')
         @imf = Iformat['header']
       end
 
       should 'respect key order' do
-        assert_equal({:show=>%w{v_title a}, :name=>"pop", :options=>{'v_title' => 'link'}}, @imf[:popup])
+        assert_equal({:show=>%w{title a}, :name=>"pop", :options=>{'title' => 'link'}}, @imf[:popup])
       end
     end
 
@@ -223,7 +223,7 @@ class IformatTest < Zena::Unit::TestCase
       end
 
       should 'respect key order' do
-        assert_equal({:show=>%w{v_title navigation created_at}, :name=>"pop", :options=>{'v_title' => 'link'}}, @imf[:popup])
+        assert_equal({:show=>%w{title navigation created_at}, :name=>"pop", :options=>{'title' => 'link'}}, @imf[:popup])
       end
     end
 

data/test/unit/image_test.rb

@@ -2,310 +2,384 @@ require 'test_helper'
 
 class ImageTest < Zena::Unit::TestCase
 
-  def test_create_with_file
-    without_files('test.host/data/jpg') do
-      login(:ant)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-                                          :inherit => 1,
-                                          :name=>'birdy',
-                                          :c_file => uploaded_jpg('bird.jpg')) }
-      assert_kind_of Image , img
-      assert ! img.new_record? , "Not a new record"
-      assert_equal "birdy", img.name
-      assert ! img.version.new_record? , "Version is not a new record"
-      assert_nil img.version.content_id , "content_id is nil"
-      assert_kind_of ImageVersion , img.version
-      assert_equal 'jpg', img.c_ext
-      assert_equal "660x600", "#{img.version.content.width}x#{img.version.content.height}"
-      assert_equal file_path("birdy.jpg", 'full', img.version.content.id), img.version.content.filepath
-      assert File.exist?(img.version.content.filepath)
-      assert_equal File.stat(img.version.content.filepath).size, img.version.content.size
-    end
-  end
-
-  def test_resize_image
-    pv_format = Iformat['pv']
-    without_files('test.host/data/jpg') do
-      login(:ant)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-                                          :inherit => 1,
-                                          :name=>'birdy', :c_file => uploaded_jpg('bird.jpg')) }
-      assert !img.new_record?, "Not a new record"
-      assert  File.exist?( img.version.content.filepath       ), "File exist"
-      assert_equal "70x70", "#{img.version.content.width(pv_format)}x#{img.version.content.height(pv_format)}"
-      assert !File.exist?( img.version.content.filepath(pv_format) ), "File does not exist"
-      assert  img.c_file(pv_format), "Can make 'pv' image"
-      assert  File.exist?( img.version.content.filepath(pv_format) ), "File exist"
-      assert_equal file_path('birdy.jpg', 'pv', img.version.content.id), img.version.content.filepath(pv_format)
-    end
-  end
-
-  def test_image_content_type
-    assert Image.accept_content_type?('image/jpeg')
-    assert !Image.accept_content_type?('application/pdf')
-  end
-
-  def test_change_image
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      flo = secure!(Node) { nodes(:flower_jpg)}
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
-      assert_equal 56243, img.version.content.size
-      assert_equal 800, flo.version.content.width
-      assert_equal 600, flo.version.content.height
-      assert_equal 96648,  flo.version.content.size
-      assert img.update_attributes(:c_file=>uploaded_jpg('flower.jpg'))
-      assert_equal flo.version.content.size,   img.version.content.size
-      assert_equal flo.version.content.width,  img.version.content.width
-      assert_equal flo.version.content.height, img.version.content.height
-      # make sure old formated images are destroyed
+  context 'The Image class' do
+    context 'receiving accept_content_type' do
+      should 'accept image/jpeg' do
+        assert Image.accept_content_type?('image/jpeg')
+      end
+
+      should 'not accept application/pdf' do
+        assert !Image.accept_content_type?('application/pdf')
+      end
     end
-  end
-
-  def test_change_image_bad_file
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      flo = secure!(Node) { nodes(:flower_jpg)}
-      assert_equal 56243, img.version.content.size
-      assert_equal 'image/jpeg', img.c_content_type
-      assert !img.update_attributes(:c_file=>uploaded_text('some.txt'))
-      img = secure!(Node) { nodes(:bird_jpg) } # reload
-      assert_equal 56243, img.version.content.size
-      assert_equal 'image/jpeg', img.c_content_type
+  end # The Image class
+
+  context 'Creating an image' do
+    setup do
+      login(:tiger)
     end
-  end
-
-  def test_crop_image
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal Zena::Status[:pub], img.version.status
-      pub_version_id = img.version.id
-      pub_content_id = img.version.content.id
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
-      assert_equal 56243, img.version.content.size
-      assert img.update_attributes(:c_crop=>{:x=>'500',:y=>30,:w=>'200',:h=>80})
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_not_equal pub_version_id, img.version.id
-      assert_not_equal pub_content_id, img.version.content.id
-      assert_equal 2010,   img.version.content.size
-      assert_equal 160,  img.version.content.width
-      assert_equal 80, img.version.content.height
-      up1 = img.updated_at
-      # crop again, same redaction
-      sleep(1)
-      assert img.update_attributes(:c_crop=>{:x=>0,:y=>0,:w=>'100',:h=>50})
-      img = secure!(Node) { nodes(:bird_jpg) }
-      # this verifies that updated_at is updated even when we only change the content
-      assert_not_equal up1, img.updated_at
-      assert_equal 100,  img.version.content.width
-      assert_equal 50, img.version.content.height
+
+    context 'with a jpg file' do
+      subject do
+        secure!(Image) { Image.create(
+          :parent_id => nodes_id(:cleanWater),
+          :title     => 'birdy',
+          :file      => uploaded_jpg('bird.jpg'))
+        }
+      end
+
+      should 'be saved in the database' do
+        assert !subject.new_record?
+      end
+
+      should 'be valid' do
+        assert subject.valid?
+      end
+
+      should 'get width and height from file' do
+        assert_equal 660, subject.width
+        assert_equal 600, subject.height
+      end
+
+      should 'get extension from file' do
+        assert_equal 'jpg', subject.ext
+      end
+
+      should 'get content type from file' do
+        assert_equal 'image/jpeg', subject.content_type
+      end
+
+      should 'build an attachment' do
+        assert_difference('Attachment.count', 1) do
+          subject
+        end
+      end
+
+      should 'build a new version' do
+        assert_difference('Version.count', 1) do
+          subject
+        end
+      end
+
+      should 'build filepath from title' do
+        assert_match /birdy.jpg/, subject.filepath
+      end
+      
+      should 'save default text' do
+        node = secure(Node) { Node.find(subject.id) }
+        assert_equal "!#{subject.zip}!", node.text
+      end
+
+      # should 'write file to filesystem' do
+      # Moved to Attachment test (no transactional fixtures)
+
+    end # with a jpg file
+
+    context 'with a file with exif tags' do
+      setup do
+        login(:tiger)
+      end
+
+      subject do
+        secure!(Image) { Image.create(
+          :parent_id => nodes_id(:cleanWater),
+          :title     => 'lake',
+          :file      => uploaded_jpg('exif_sample.jpg'))
+        }
+      end
+
+      should 'read Make from exif data' do
+        assert_equal 'SANYO Electric Co.,Ltd.', subject.exif['Make']
+      end
+
+      should 'save exif data in database' do
+        subject.reload
+        assert_equal 'SANYO Electric Co.,Ltd.', subject.exif['Make']
+      end
+
+      should 'save exif data in exif prop' do
+        assert_kind_of ExifData, subject.prop['exif']
+      end
+
+      should 'parse time values' do
+        assert_equal Time.parse("1998-01-01 00:00:00"), subject.exif.date_time
+      end
+
+      should 'use exif date_time as event_at' do
+        assert_equal Time.parse("1998-01-01 00:00:00"), subject.event_at
+      end
+    end # with a file with exif tags
+  end # Creating an image
+
+  context 'An image' do
+    setup do
+      login(:tiger)
     end
-  end
-
-  def test_crop_image_limit
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal Zena::Status[:pub], img.version.status
-      pub_version_id = img.version.id
-      pub_content_id = img.version.content.id
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
-      assert_equal 56243, img.version.content.size
-      assert img.update_attributes(:c_crop=>{:max_value=>'30', :max_unit=>'Kb'})
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_not_equal pub_version_id, img.version.id
-      assert_not_equal pub_content_id, img.version.content.id
-      assert img.version.content.size < 30 * 1024 * 1.2
+
+    subject do
+      secure!(Node) { nodes(:bird_jpg) }
     end
-  end
-
-  def test_crop_iformat
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal Zena::Status[:pub], img.version.status
-      pub_version_id = img.version.id
-      pub_content_id = img.version.content.id
-      img.update_attributes(:c_crop=>{:format=>'png'})
-      # should build a new version
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_not_equal pub_version_id, img.version.id
-      assert_not_equal pub_content_id, img.version.content.id
-      #assert_equal 20799,   img.version.content.size
-      assert_equal 'png', img.c_ext
+
+    context 'with a given image format' do
+      setup do
+        @pv = Iformat['pv']
+      end
+
+      should 'return calculated width and height for format' do
+        assert_equal 70, subject.width(@pv)
+        assert_equal 70, subject.width(@pv)
+      end
+
+      should 'create a new file in a folder named after the format' do
+        assert_match /pv/, subject.filepath(@pv)
+      end
+
+      should 'return the original path by default' do
+        assert_match /full/, subject.filepath
+      end
+
+      should 'create a new file corresponding to the new format on file' do
+        preserving_files('test.host/zafu') do
+          subject.file(@pv)
+          assert File.exist?( subject.filepath(@pv) )
+        end
+      end
+
+      should 'return a file corresponding to the format' do
+        preserving_files('test.host/zafu') do
+          assert_kind_of File, subject.file(@pv)
+        end
+      end
+
+      should 'not create a version' do
+        assert_difference('Version.count', 0) do
+          assert_difference('Attachment.count', 0) do
+            preserving_files('test.host/zafu') do
+              subject.file(@pv)
+            end
+          end
+        end
+      end
+    end # with a given image format
+
+    context 'without an image format' do
+      should 'return full resolution on width and height' do
+        assert_equal 660, subject.width
+        assert_equal 600, subject.height
+      end
+
+      should 'return original file size' do
+        assert_equal 56243, subject.size
+      end
     end
-  end
-
-  def test_crop_image_same_size
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal Zena::Status[:pub], img.version.status
-      pub_version_id = img.version.id
-      pub_content_id = img.version.content.id
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
-      # crop keeping same size => do nothing => keep content
-      assert !img.version.content.can_crop?('x'=>'0','y'=>0,'w'=>'660','h'=>600)
-      img.update_attributes(:v_text=>"hey", :c_crop=>{:x=>'0',:y=>0,:w=>'660',:h=>600})
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_not_equal pub_version_id, img.version.id
-      assert_equal pub_version_id, img.version.content_id
-      assert_equal pub_content_id, img.version.content.id
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
+
+    should 'return content_type' do
+      assert_equal 'image/jpeg', subject.content_type
     end
-  end
-
-  def test_crop_image_with_new_file
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal Zena::Status[:pub], img.version.status
-      pub_version_id = img.version.id
-      pub_content_id = img.version.content.id
-      assert_equal 660, img.version.content.width
-      assert_equal 600, img.version.content.height
-      assert_equal 56243, img.version.content.size
-      assert img.update_attributes(:name => 'lila.jpg', :c_file=>uploaded_jpg('flower.jpg'), :c_crop=>{:x=>'500',:y=>30,:w=>'200',:h=>80})
-      img = secure!(Node) { nodes(:bird_jpg) }
-      assert_equal 800, img.version.content.width
-      assert_equal 600, img.version.content.height
-      assert_equal 96648,  img.version.content.size
+  end # An image
+
+  context 'Updating an image' do
+    setup do
+      login(:tiger)
     end
-  end
-
-  def test_change_name
-    preserving_files('test.host/data') do
-      login(:ant)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-                                          :inherit => 1,
-                                          :name=>'birdy',
-                                          :c_file => uploaded_jpg('bird.jpg')) }
-      assert !img.new_record?
-      img = secure!(Image) { Image.find(img[:id]) }
-      old_path1 = img.version.content.filepath
-      pv_format = Iformat['pv']
-      old_path2 = img.version.content.filepath(pv_format)
-      img.c_file(pv_format) # creates 'pv' file
-      assert_equal file_path("birdy.jpg", 'full', img.version.content.id), old_path1
-      assert_equal file_path("birdy.jpg", 'pv', img.version.content.id), old_path2
-      assert File.exists?(old_path1), "Old file exist."
-      assert File.exists?(old_path2), "Old file with 'pv' format exist."
-      assert img.update_attributes(:name=>'moineau')
-      # image content name should not change
-      assert_equal old_path1, img.version.content.filepath
-      assert File.exists?(old_path1), "Old file exist."
-      assert File.exists?(old_path2), "Old file with 'pv' format exist."
+
+    subject do
+      secure!(Node) { nodes(:bird_jpg) }
     end
-  end
 
-  def test_change_name_many_versions
-    preserving_files('test.host/data') do
-      login(:lion)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-                                          :inherit => 1,
-                                          :name=>'birdy',
-                                          :c_file => uploaded_jpg('bird.jpg')) }
+    context 'with a new title' do
+      should 'not change filepath' do
+        filepath1 = subject.filepath
+        assert subject.update_attributes(:title => 'Milan')
+        assert_equal filepath1, subject.filepath
+      end
+    end # with a new title
+
+    context 'with a new file' do
+      setup do
+        subject.update_attributes(:file => uploaded_jpg('flower.jpg'))
+      end
+
+      should 'be valid' do
+        assert subject.valid?
+      end
+
+      should 'be saved in the database' do
+        assert !subject.new_record?
+      end
+
+      should 'not change file name' do
+        assert_equal 'bird.jpg', subject.filename
+      end
 
-                                          err img
-      assert !img.new_record?
+      should 'not change filepath' do
+        assert_match /bird.jpg/, subject.filepath
+      end
+
+      should 'change width' do
+        assert_equal 800, subject.width
+      end
 
-      img = secure!(Image) { Image.find(img[:id]) }
-      assert img.publish
-      img_id  = img[:id]
-      v1      = img.version.id
-      old1    = img.version.content.filepath
-      pv_format = Iformat['pv']
-      old1_pv = img.version.content.filepath(pv_format)
-      img.c_file(pv_format) # creates 'pv' file
+      should 'change height' do
+        assert_equal 600, subject.height
+      end
 
-      img = secure!(Image) { Image.find(img_id) }
-      # create a new redaction with a new file
-      assert img.update_attributes(:c_file=> uploaded_jpg('flower.jpg'))
+      should 'change size' do
+        assert_equal 96648, subject.size
+      end
 
-      # publish new redaction
-      assert img.publish
+      # should 'change saved file'
+      # Moved to Attachment test (no transactional fixtures)
 
-      v2      = img.version.id
-      old2    = img.version.content.filepath
-      old2_pv = img.version.content.filepath(pv_format)
+    end # with a new file
 
-      img.c_file(pv_format) # creates 'pv' file
+    context 'with a document file' do
+      setup do
+        subject.update_attributes(:file => uploaded_text('some.txt'))
+      end
 
-      [old1,old1_pv,old2,old2_pv].each do |path|
-        assert File.exists?(path), "Path #{path.inspect} should exist"
+      should 'add an error on file' do
+        assert_equal 'incompatible with this class', subject.errors[:file]
       end
 
-      # We do not propagate 'name' change to document_content 'name' because this is only used to find document content and
-      # retrieve data in case the whole database goes havoc.
-      assert img.update_attributes(:name=>'moineau')
+      should 'not change content type' do
+        assert 'image/jpeg', subject.content_type
+      end
 
-      [old1,old1_pv,old2,old2_pv].each do |path|
-        assert File.exists?(path), "Path #{path.inspect} did not change"
+      should 'not change file name' do
+        assert 'flower.jpg', subject.filename
       end
 
-      version1 = Version.find(v1)
-      version2 = Version.find(v2)
-      new1 = version1.content.filepath
-      new2 = version2.content.filepath
-      assert File.exists?(new1), "New file exists"
-      assert File.exists?(new2), "New file exists"
-    end
-  end
-
-  def test_create_with_small_file
-    preserving_files('/sites/test.host/data') do
-      login(:ant)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-        :name => 'bomb.png',
-        :c_file => uploaded_png('bomb.png') )}
-      assert_kind_of Image, img
-      assert ! img.new_record?, "Not a new record"
-      assert_equal 793, img.version.content.size
-      assert img.c_file(Iformat['pv'])
-    end
-  end
-
-  def test_update_same_image
-    login(:tiger)
-    bird = secure!(Node) { nodes(:bird_jpg) }
-    assert_equal Digest::MD5.hexdigest(bird.c_file.read),
-                 Digest::MD5.hexdigest(uploaded_jpg('bird.jpg').read)
-    bird.c_file.rewind
-    assert_equal 1, bird.versions.count
-    assert_equal '2006-04-11 00:00', bird.updated_at.strftime('%Y-%m-%d %H:%M')
-    assert !bird.version.would_edit?('content_attributes' => {'file' => uploaded_jpg('bird.jpg')})
-    assert bird.update_attributes(:c_file => uploaded_jpg('bird.jpg'))
-    assert_equal 1, bird.versions.count
-    assert_equal '2006-04-11 00:00', bird.updated_at.strftime('%Y-%m-%d %H:%M')
-    assert bird.update_attributes(:c_file => uploaded_jpg('flower.jpg'))
-    assert_equal 2, bird.versions.count
-    assert_not_equal '2006-04-11 00:00', bird.updated_at.strftime('%Y-%m-%d %H:%M')
-  end
-
-  def test_set_event_at_from_exif_tags
-    without_files('test.host/data/jpg') do
-      login(:ant)
-      img = secure!(Image) { Image.create( :parent_id=>nodes_id(:cleanWater),
-                                          :inherit => 1,
-                                          :name=>'lake',
-                                          :c_file => uploaded_jpg('exif_sample.jpg')) }
-      assert_equal 'SANYO Electric Co.,Ltd.', img.c_exif['Make']
-
-      # reload
-      assert img = secure!(Image) { Image.find(img.id) }
-      assert exif_tags = img.c_exif
-      assert_equal 'SANYO Electric Co.,Ltd.', img.c_exif['Make']
-      assert_equal Time.parse("1998-01-01 00:00:00"), img.c_exif.date_time
-      assert_equal Time.parse("1998-01-01 00:00:00"), img.event_at
+      should 'not change file path' do
+        image = secure!(Node) { Node.find(subject.id) }
+        assert_match /bird.jpg/, image.filepath
+      end
+
+      should 'not create a version' do
+        assert_difference('Version.count', 0) do
+          subject
+        end
+      end
+    end # with a document file
+
+    context 'by cropping' do
+      context 'with x, y, w, h' do
+        subject do
+          secure!(Node) { nodes(:bird_jpg) }.tap do |n|
+            n.update_attributes(
+              :crop => {:x => '500', :y => 30, :w => '180', :h => 80}
+            )
+          end
+        end
+
+        should 'save a new version' do
+          assert_difference('Version.count', 1) do
+            subject
+          end
+        end
+
+        should 'clip and modify width from x and w' do
+          # 660 - 500 = 160
+          # 160 = min(160, 180)
+          assert_equal 160, subject.width
+        end
+
+        should 'clip and modify height from y and h' do
+          # 600 - 30 = 570
+          # 80 = min(570, 80)
+          assert_equal 80, subject.height
+        end
+      end # with x,y,w,h
+
+      context 'with max size' do
+
+        setup do
+          subject.update_attributes(
+            :crop => {'max_value' => '30', 'max_unit' => 'Kb'}
+          )
+        end
+
+        should 'reduce file size' do
+          assert subject.valid?
+          assert subject.size < 30 * 1024 * 1.2
+        end
+      end # with limitation
+
+      context 'with a format' do
+        setup do
+          subject.update_attributes(:crop => {:format => 'png'})
+        end
+
+        should 'change type' do
+          assert_equal 'image/png', subject.content_type
+          assert_equal 'png', subject.ext
+        end
+      end # with a format
+
+
+      context 'with same size' do
+        setup do
+          subject.update_attributes(
+            :crop => {:x => '0', :y => 0, :w => '660', :h => 600 }
+          )
+        end
+
+        should 'not change version' do
+          assert_difference('Version.count', 0) do
+            subject
+          end
+
+          assert_equal 660, subject.width
+          assert_equal 600, subject.height
+        end
+      end # with same size
+
+      context 'with a new file' do
+
+        should 'change file and crop' do
+          assert_difference('Version.count', 1) do
+            subject.update_attributes(
+              :file => uploaded_jpg('flower.jpg'),
+              :crop => {:x => '500', :y => 30, :w =>'200',:h => 80}
+            )
+            assert_equal 800, subject.width
+            assert_equal 600, subject.height
+            assert_equal 96648,  subject.size
+          end
+        end
+      end # with new file
+    end # by cropping
+  end # Updating an image
+
+  context 'Destroying' do
+    setup do
+      login(:tiger)
     end
-  end
 
-end
+    context 'an image' do
+      subject do
+        secure!(Node) { nodes(:bird_jpg) }
+      end
+
+      should 'destroy version from database' do
+        assert_difference('Version.count', -1) do
+          subject.destroy
+        end
+      end
+
+      should 'destroy attachment from database' do
+        assert_difference('Attachment.count', -1) do
+          subject.destroy
+        end
+      end
+
+      # should 'destroy file from file system'
+      # Moved to Attachment test (no transactional fixtures)
+
+      # context 'with iformats'
+      # Moved to Attachment test (no transactional fixtures)
+
+    end # an image
+  end # Destroying
+end # ImageTest
+