versions 0.1.0 → 0.2.0

data/lib/versions/version.rb

@@ -1,3 +1,3 @@
 module Versions
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/test/fixtures.rb

@@ -31,7 +31,8 @@ begin
         t.string  'properties'
         t.integer 'attachment_id'
         t.integer 'number'
-        t.integer 'owner_id'
+        t.integer 'page_id'
+        t.integer 'node_id'
         t.timestamps
       end
 
@@ -44,7 +45,10 @@ begin
   end
 
   ActiveRecord::Base.establish_connection(:adapter=>'sqlite3', :database=>':memory:')
-  ActiveRecord::Migration.verbose = false
-  VersionsMigration.migrate(:up)
-  ActiveRecord::Migration.verbose = true
+  ActiveRecord::Base.logger = Logger.new(File.open(Pathname(__FILE__).dirname + 'test.log', 'wb'))
+  #if !ActiveRecord::Base.connection.table_exists?('pages')
+    ActiveRecord::Migration.verbose = false
+    VersionsMigration.migrate(:up)
+    ActiveRecord::Migration.verbose = true
+  #end
 end

data/test/helper.rb

@@ -1,16 +1,48 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'active_record'
+require 'active_support'
+require 'active_support/testing/assertions'
+require 'tempfile'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-require 'active_record'
-require 'active_support'
-require 'active_support/testing/assertions'
 require 'versions'
 require 'fixtures'
 
 class Test::Unit::TestCase
   include ActiveSupport::Testing::Assertions
+  FILE_FIXTURES_PATH = Pathname(__FILE__).dirname + 'fixtures/files'
+
+  # taken from http://manuals.rubyonrails.com/read/chapter/28#page237 with some modifications
+  def uploaded_fixture(fname, content_type="application/octet-stream", filename=nil)
+    path = File.join(FILE_FIXTURES_PATH, fname)
+    filename ||= File.basename(path)
+    # simulate small files with StringIO
+    if File.stat(path).size < 1024
+      # smaller then 1 Ko
+      t = StringIO.new(File.read(path))
+    else
+      t = Tempfile.new(fname)
+      FileUtils.copy_file(path, t.path)
+    end
+    uploaded_file(t, filename, content_type)
+  end
+
+  # JPEG helper
+  def uploaded_jpg(fname, filename=nil)
+    uploaded_fixture(fname, 'image/jpeg', filename)
+  end
+
+  private
+    def uploaded_file(file, filename = nil, content_type = nil)
+      (class << file; self; end;).class_eval do
+        alias local_path path if respond_to?(:path)  # FIXME: do we need this ?
+        define_method(:original_filename) { filename }
+        define_method(:content_type) { content_type }
+      end
+      file
+    end
 end

data/test/unit/after_commit_test.rb

@@ -0,0 +1,107 @@
+require 'helper'
+
+class AfterCommitTest < Test::Unit::TestCase
+  class Page < ActiveRecord::Base
+    attr_accessor :actions
+    before_save :do_action
+    after_save  :raise_to_rollback
+    validates_presence_of :name
+
+    def after_commit_actions
+      @after_commit_actions ||= []
+    end
+
+    private
+      def do_action
+        after_commit do
+          after_commit_actions << 'executed'
+        end
+      end
+
+      def raise_to_rollback
+        raise ActiveRecord::Rollback if self[:name] == 'raise'
+      end
+  end
+
+  context 'Creating a valid page' do
+    should 'trigger after_commit once all is done' do
+      page = Page.create(:name => 'hello')
+      assert_equal ['executed'], page.after_commit_actions
+    end
+
+    context 'inside a transaction' do
+      should 'trigger after_commit after last transaction' do
+        page = nil
+        Page.transaction do
+          page = Page.create(:name => 'hello')
+          assert_equal [], page.after_commit_actions
+        end
+        assert_equal ['executed'], page.after_commit_actions
+      end
+
+      should 'not trigger after_commit if outer transaction fails' do
+        page = nil
+        begin
+          Page.transaction do
+            page = Page.create(:name => 'hello')
+            assert_equal [], page.after_commit_actions
+            raise 'Something went bad'
+          end
+        rescue Exception => err
+        end
+        assert_equal [], page.after_commit_actions
+      end
+
+      should 'not trigger after_commit on rollback' do
+        page = nil
+        Page.transaction do
+          page = Page.create(:name => 'hello')
+          assert_equal [], page.after_commit_actions
+          raise ActiveRecord::Rollback
+        end
+        assert_equal [], page.after_commit_actions
+      end
+
+      should 'clear after_commit after transaction' do
+        actions = []
+        Page.transaction do
+          Page.after_commit do
+            actions << 'executed'
+          end
+          raise ActiveRecord::Rollback
+        end
+        assert_equal [], actions
+
+        Page.transaction do
+        end
+        assert_equal [], actions
+      end
+
+    end
+  end
+
+  context 'Creating an invalid page' do
+    should 'not trigger after_commit' do
+      page = Page.create
+      assert page.new_record?
+      assert_equal [], page.after_commit_actions
+    end
+  end
+
+  context 'Raising an error after save' do
+    should 'not trigger after_commit' do
+      page = Page.create(:name => 'raise')
+      assert_equal [], page.after_commit_actions
+    end
+  end
+
+  should 'not allow after commit outside of a transaction' do
+    assert_raise(Exception) do
+      Page.new.instance_eval do
+        after_commit do
+          # never executed
+        end
+      end
+    end
+  end
+end

data/test/unit/attachment_test.rb

@@ -1,222 +1,260 @@
 require 'helper'
 
-#class SharedAttachmentTest < Zena::Unit::TestCase
-#  self.use_transactional_fixtures = false
-#
-#  Attachment = Class.new(Zena::Use::SharedAttachment::Attachment) do
-#    def filepath
-#      File.join(RAILS_ROOT, 'tmp', 'attachments', super)
-#    end
-#  end
-#
-#  # Mock a document class with many versions
-#  class Document < ActiveRecord::Base
-#    include Zena::Use::MultiVersion
-#
-#    set_table_name :nodes
-#    before_save :set_dummy_defaults
-#
-#    def title=(title)
-#      version.title = title
-#    end
-#
-#    def file=(file)
-#      version.file = file
-#    end
-#
-#    def version
-#      @version ||= new_record? ? versions.build : versions.first(:order => 'id DESC')
-#    end
-#    private
-#      def set_dummy_defaults
-#        self[:user_id] ||= 0
-#      end
-#  end
-#
-#  # Mock a version class with shared attachments (between versions of the same document)
-#  class Version < ActiveRecord::Base
-#    include Zena::Use::MultiVersion::Version
-#    include Zena::Use::AutoVersion
-#    include Zena::Use::SharedAttachment
-#    set_attachment_class 'SharedAttachmentTest::Attachment'
-#    set_table_name :versions
-#
-#    def should_clone?
-#      true
-#    end
-#
-#    private
-#      def setup_version_on_create
-#        # Dummy values when testing Version without a Document
-#        self[:node_id] ||= 0
-#        self[:user_id] ||= 0
-#        self[:status]  ||= 0
-#      end
-#  end
-#
-#  def setup
-#    FileUtils.rmtree(File.join(RAILS_ROOT, 'tmp', 'attachments'))
-#  end
-#
-#  context 'When creating a new owner' do
-#    setup do
-#      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
-#    end
-#
-#    should 'store file in the filesystem' do
-#      assert File.exist?(@owner.filepath)
-#      assert_equal uploaded_jpg('bird.jpg').read, File.read(@owner.filepath)
-#    end
-#
-#    should 'restore the filepath from the database' do
-#      attachment = Attachment.find(@owner.attachment_id)
-#      assert_equal @owner.filepath, attachment.filepath
-#    end
-#  end
-#
-#  context 'When the transaction fails' do
-#    should 'not write file on create' do
-#      owner    = nil
-#      filepath = nil
-#      assert_difference('Attachment.count', 0) do
-#        Version.transaction do
-#          owner = Version.create(:file => uploaded_jpg('bird.jpg'))
-#          filepath = owner.filepath
-#          assert !File.exist?(filepath)
-#          raise ActiveRecord::Rollback
-#        end
-#      end
-#      assert !File.exist?(filepath)
-#    end
-#
-#    should 'not remove file on destroy' do
-#      @owner   = Version.create(:file => uploaded_jpg('bird.jpg'))
-#      filepath = @owner.filepath
-#      assert File.exist?(filepath)
-#      assert_difference('Attachment.count', 0) do
-#        Version.transaction do
-#          @owner.destroy
-#          assert File.exist?(filepath)
-#          raise ActiveRecord::Rollback
-#        end
-#      end
-#      assert File.exist?(filepath)
-#    end
-#  end
-#
-#  context 'On an owner with a file' do
-#    setup do
-#      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
-#      @owner = Version.find(@owner.id)
-#    end
-#
-#    should 'remove file in the filesystem when updating file' do
-#      old_filepath = @owner.filepath
-#      puts "Start"
-#      assert_difference('Attachment.count', 0) do # destroy + create
-#        assert @owner.update_attributes(:file => uploaded_jpg('lake.jpg'))
-#      end
-#      assert_not_equal old_filepath, @owner.filepath
-#      assert File.exist?(@owner.filepath)
-#      assert_equal uploaded_jpg('lake.jpg').read, File.read(@owner.filepath)
-#      assert !File.exist?(old_filepath)
-#    end
-#  end
-#
-#  context 'Updating document' do
-#    setup do
-#      begin
-#        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
-#      rescue => err
-#        puts err.message
-#        puts err.backtrace.join("\n")
-#      end
-#    end
-#
-#    # Updating document ...attributes
-#    context 'attributes' do
-#      setup do
-#        assert_difference('Version.count', 1) do
-#          @doc.update_attributes(:title => 'hopla')
-#        end
-#      end
-#
-#      should 'reuse the same filepath in new versions' do
-#        filepath = nil
-#        @doc.versions.each do |version|
-#          if filepath
-#            assert_equal filepath, version.filepath
-#          else
-#            filepath = version.filepath
-#          end
-#        end
-#      end
-#    end
-#
-#    # Updating document ...file
-#    context 'file' do
-#      setup do
-#        assert_difference('Version.count', 1) do
-#          @doc.update_attributes(:file => uploaded_jpg('lake.jpg'))
-#        end
-#      end
-#
-#      should 'create new filepath' do
-#        filepath = nil
-#        @doc.versions.each do |version|
-#          if filepath
-#            assert_not_equal filepath, version.filepath
-#          else
-#            filepath = version.filepath
-#          end
-#        end
-#      end
-#    end # Updating document .. file
-#  end # Updating document
-#
-#  context 'On a document with many versions' do
-#    setup do
-#      assert_difference('Version.count', 2) do
-#        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
-#        @doc.update_attributes(:title => 'Vögel')
-#        @doc = Document.find(@doc.id)
-#      end
-#    end
-#
-#    context 'removing a version' do
-#
-#      should 'not remove shared attachment' do
-#        filepath = @doc.version.filepath
-#
-#        assert_difference('Version.count', -1) do
-#          assert_difference('Attachment.count', 0) do
-#            assert @doc.version.destroy
-#          end
-#        end
-#        assert File.exist?(filepath)
-#      end
-#    end
-#
-#    context 'removing the last version' do
-#
-#      should 'remove shared attachment' do
-#        filepath = @doc.version.filepath
-#
-#        assert_difference('Version.count', -2) do
-#          assert_difference('Attachment.count', -1) do
-#            @doc.versions.each do |version|
-#              assert version.destroy
-#            end
-#          end
-#        end
-#        assert !File.exist?(filepath)
-#      end
-#    end
-#  end
-#
-#  private
-#    def filepath(attachment_id, filename)
-#      digest = Digest::SHA1.hexdigest(attachment_id.to_s)
-#      "#{digest[0..0]}/#{digest[1..1]}/#{filename}"
-#    end
-#end
+class AttachmentTest < Test::Unit::TestCase
+  @@attachments_dir = (Pathname(__FILE__).dirname + 'tmp').expand_path
+
+  Attachment = Class.new(Versions::SharedAttachment) do
+    def filepath
+      File.join(@@attachments_dir, super)
+    end
+  end
+
+  # Mock a version class with shared attachments (between versions of the same document)
+  class Version < ActiveRecord::Base
+    include Versions::Auto
+  end
+
+  # Mock a document class with many versions
+  class Document < ActiveRecord::Base
+    include Versions::Multi
+    has_multiple :versions, :class_name => 'AttachmentTest::Version', :inverse => 'node'
+
+    include Versions::Attachment
+    store_attachments_in :version, :class_name => 'AttachmentTest::Version', :attachment_class => 'AttachmentTest::Attachment'
+
+    set_table_name :pages
+
+    def title
+      version.title
+    end
+
+    def title=(t)
+      version.title = t
+    end
+  end
+
+
+  def setup
+    FileUtils.rmtree(@@attachments_dir)
+  end
+
+  context 'When creating a new owner' do
+    setup do
+      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+    end
+
+    should 'store file in the filesystem' do
+      assert File.exist?(@owner.filepath)
+      assert_equal uploaded_jpg('bird.jpg').read, File.read(@owner.filepath)
+    end
+
+    should 'restore the filepath from the database' do
+      attachment = Attachment.find(@owner.attachment_id)
+      assert_equal @owner.filepath, attachment.filepath
+    end
+
+    should 'rename file on bad original_filename' do
+      file = uploaded_jpg('bird.jpg')
+      class << file
+        def original_filename
+          '../../bad.txt'
+        end
+      end
+      owner = Version.create(:file => file)
+      assert File.exist?(owner.filepath)
+      assert_no_match %r{bird\.jpg}, owner.filepath
+      assert_no_match %r{bad\.txt}, owner.filepath
+    end
+  end
+
+  context 'When the transaction fails' do
+    should 'not write file on create' do
+      owner    = nil
+      filepath = nil
+      assert_difference('Attachment.count', 0) do
+        Version.transaction do
+          owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+          filepath = owner.filepath
+          assert !File.exist?(filepath)
+          raise ActiveRecord::Rollback
+        end
+      end
+      assert !File.exist?(filepath)
+    end
+
+    should 'not remove file on destroy' do
+      @owner   = Version.create(:file => uploaded_jpg('bird.jpg'))
+      filepath = @owner.filepath
+      assert File.exist?(filepath)
+      assert_difference('Attachment.count', 0) do
+        Version.transaction do
+          @owner.destroy
+          assert File.exist?(filepath)
+          raise ActiveRecord::Rollback
+        end
+      end
+      assert File.exist?(filepath)
+    end
+  end
+
+  context 'On an owner with a file' do
+    setup do
+      @owner = Version.create(:file => uploaded_jpg('bird.jpg'))
+      @owner = Version.find(@owner.id)
+      @owner.class_eval do
+        def should_clone?
+          false
+        end
+      end
+    end
+
+    should 'remove file in the filesystem when updating file' do
+      old_filepath = @owner.filepath
+      assert_difference('Attachment.count', 0) do # destroy + create
+        assert @owner.update_attributes(:file => uploaded_jpg('lake.jpg'))
+      end
+      assert_not_equal old_filepath, @owner.filepath
+      assert File.exist?(@owner.filepath)
+      assert_equal uploaded_jpg('lake.jpg').read, File.read(@owner.filepath)
+      assert !File.exist?(old_filepath)
+    end
+  end
+
+  context 'Updating document' do
+    setup do
+      begin
+        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
+      rescue => err
+        puts err.message
+        puts err.backtrace.join("\n")
+      end
+    end
+
+    # Updating document ...attributes
+    context 'attributes' do
+      setup do
+        assert_difference('Version.count', 1) do
+          @doc.update_attributes(:title => 'hopla')
+        end
+      end
+
+      should 'reuse the same filepath in new versions' do
+        filepath = nil
+        @doc.versions.each do |version|
+          if filepath
+            assert_equal filepath, version.filepath
+          else
+            filepath = version.filepath
+          end
+        end
+      end
+    end
+
+    # Updating document ...file
+    context 'file' do
+      setup do
+        assert_difference('Version.count', 1) do
+          @doc.update_attributes(:file => uploaded_jpg('lake.jpg'))
+        end
+      end
+
+      should 'create new filepath' do
+        filepath = nil
+        @doc.versions.each do |version|
+          if filepath
+            assert_not_equal filepath, version.filepath
+          else
+            filepath = version.filepath
+          end
+        end
+      end
+    end # Updating document .. file
+  end # Updating document
+
+  context 'On a document with many versions' do
+    setup do
+      assert_difference('Version.count', 2) do
+        @doc = Document.create(:title => 'birdy', :file => uploaded_jpg('bird.jpg'))
+        @doc.update_attributes(:title => 'Vögel')
+        @doc = Document.find(@doc.id)
+      end
+    end
+
+    context 'removing a version' do
+
+      should 'not remove shared attachment' do
+        filepath = @doc.version.filepath
+
+        assert_difference('Version.count', -1) do
+          assert_difference('Attachment.count', 0) do
+            assert @doc.version.destroy
+          end
+        end
+        assert File.exist?(filepath)
+      end
+    end
+
+    context 'removing the last version' do
+
+      should 'remove shared attachment' do
+        filepath = @doc.version.filepath
+
+        assert_difference('Version.count', -2) do
+          assert_difference('Attachment.count', -1) do
+            @doc.versions.each do |version|
+              assert version.destroy
+            end
+          end
+        end
+        assert !File.exist?(filepath)
+      end
+    end
+  end
+
+  context 'A module using attachments without versions' do
+    class Doc < ActiveRecord::Base
+      set_table_name :versions
+      include Versions::Attachment
+      store_attachments_in self, :attachment_class => 'AttachmentTest::Attachment'
+    end
+
+    subject do
+      Doc.create('file' => uploaded_jpg('bird.jpg'))
+    end
+
+    should 'accept files' do
+      assert !subject.new_record?
+    end
+
+    should 'store file in the filesystem' do
+      assert File.exist?(subject.filepath)
+      assert_equal uploaded_jpg('bird.jpg').read, File.read(subject.filepath)
+    end
+
+    should 'restore the filepath from the database' do
+      attachment = Attachment.find(subject.attachment_id)
+      assert_equal subject.filepath, attachment.filepath
+    end
+
+    should 'remove file in the filesystem when updating file' do
+      old_filepath = subject.filepath
+      assert_difference('Attachment.count', 0) do # destroy + create
+        assert subject.update_attributes(:file => uploaded_jpg('lake.jpg'))
+      end
+      assert_not_equal old_filepath, subject.filepath
+      assert File.exist?(subject.filepath)
+      assert_equal uploaded_jpg('lake.jpg').read, File.read(subject.filepath)
+      assert !File.exist?(old_filepath)
+    end
+
+    should 'create and destroy objects without attachments' do
+      assert Doc.create.destroy
+    end
+  end
+
+  private
+    def filepath(attachment_id, filename)
+      digest = Digest::SHA1.hexdigest(attachment_id.to_s)
+      "#{digest[0..0]}/#{digest[1..1]}/#{filename}"
+    end
+end