browsercms_s3 3.0.3

data/test/unit/models/attachment_test.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class AttachmentTest < ActiveSupport::TestCase
+  
+  def test_creating_an_attachment_witn_no_file
+    attachment = Attachment.new
+    assert_not_valid attachment
+    assert_has_error_on attachment, :temp_file, "You must upload a file"
+  end
+  
+  def test_creating_an_attachment_with_a_StringIO_file
+    file = ActionController::UploadedStringIO.new("This is a file")
+    file.original_path = "bar.txt"
+    file.content_type = "text/plain"
+    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
+    attachment.save!
+    assert_equal "foo.txt", attachment.file_name
+    assert_equal "text/plain", attachment.file_type
+    assert_equal "txt", attachment.file_extension
+    assert_file_exists attachment.full_file_location
+    assert_equal "This is a file", open(attachment.full_file_location){|f| f.read}
+  end
+  
+  def test_creating_an_attachment_with_a_Tempfile_file
+    file = ActionController::UploadedTempfile.new("foo.txt")
+    open(file.path, 'w') {|f| f << "This is a file"}
+    file.original_path = "bar.txt"
+    file.content_type = "text/plain"
+    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
+    attachment.save!
+  
+    assert_equal "foo.txt", attachment.file_name
+    assert_file_exists attachment.full_file_location
+    assert_equal "This is a file", open(attachment.full_file_location){|f| f.read}
+    
+    # If you change the attributes of the attachment, but don't change the file
+    # the file_location should not change
+    original_file_location = attachment.file_location
+    attachment = Attachment.find(attachment.id)
+    attachment.update_attributes(:file_path => "bar.txt")
+    assert_equal 2, attachment.draft.version
+    assert_equal "/bar.txt", attachment.file_path
+    assert_equal "bar.txt", attachment.file_name
+    assert_equal original_file_location, attachment.file_location
+    
+    # If you change the file of the attachment, the file_location should change
+    attachment = Attachment.find(attachment.id)
+    file = ActionController::UploadedTempfile.new("foo.txt")
+    open(file.path, 'w') {|f| f << "This is a new file"}
+    file.original_path = "foo.txt"
+    file.content_type = "text/plain"    
+    attachment.update_attributes(:temp_file => file)
+    # log_table_with Attachment, :id, :name, :version, :file_path
+    # log_table_with Attachment::Version, :id, :name, :version, :file_path, :attachment_id
+    assert_equal 3, attachment.draft.version 
+    assert_equal "/bar.txt", attachment.as_of_draft_version.file_path
+    assert_equal "bar.txt", attachment.as_of_draft_version.file_name
+    assert_not_equal original_file_location, attachment.as_of_draft_version.file_location
+    assert_equal "This is a new file", open(attachment.as_of_draft_version.full_file_location){|f| f.read}  
+  end
+  
+  def test_find_live_by_file_path
+    file = ActionController::UploadedTempfile.new("foo.txt")
+    open(file.path, 'w') {|f| f << "This is a file"}
+    file.original_path = "bar.txt"
+    file.content_type = "text/plain"
+    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
+    attachment.save!
+    assert !attachment.published?, "Attachment should not be published"
+    assert_nil Attachment.find_live_by_file_path("/foo.txt")
+    
+    attachment.publish
+    assert attachment.reload.published?, "Attachment should be published"
+    assert_equal attachment, Attachment.find_live_by_file_path("/foo.txt")
+    
+    attachment.update_attributes(:file_type => "text/html")
+    assert !attachment.live?, "Attachment should not be live"
+    assert_equal attachment.as_of_version(2), Attachment.find_live_by_file_path("/foo.txt")    
+  end
+  
+  def test_update_attachment_section
+    file = ActionController::UploadedTempfile.new("foo.txt")
+    open(file.path, 'w') {|f| f << "This is a file"}
+    file.original_path = "bar.txt"
+    file.content_type = "text/plain"
+    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
+    attachment.save!
+
+    new_section = Factory(:section, :name => "New")
+    assert_equal root_section, attachment.section
+    
+    attachment.update_attributes!(:section => new_section)
+    assert_equal new_section, attachment.section
+  end
+  
+end

data/test/unit/models/category_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class CategoryTest < ActiveSupport::TestCase
+  def test_creating_categories
+    @a_type = Factory(:category_type, :name => "A")
+    @b_type = Factory(:category_type, :name => "B")
+    
+    @a = Factory(:category, :name => "A", :category_type => @a_type)
+    @a1 = Factory(:category, :name => "A1", :category_type => @a_type, :parent => @a)
+    @a1a = Factory(:category, :name => "A1a", :category_type => @a_type, :parent => @a1)
+    @a2 = Factory(:category, :name => "A2", :category_type => @a_type, :parent => @a)
+    @b = Factory(:category, :name => "B", :category_type => @b_type)
+    @b1 = Factory(:category, :name => "B1", :category_type => @b_type, :parent => @b)
+    @b2 = Factory(:category, :name => "B2", :category_type => @b_type, :parent => @b)
+    
+    assert @a.parent.blank?
+    assert_equal [@a1, @a2], @a.children
+    
+    assert_equal @a, @a1.parent
+    assert_equal [@a1a], @a1.children
+    
+    assert_equal @a, @a2.parent
+    assert @a2.children.blank?
+    
+    assert @a.ancestors.blank?
+    assert_equal [@a], @a1.ancestors
+    assert_equal [@a, @a1], @a1a.ancestors
+    
+    assert_equal "#{@a.name}", @a.path
+    assert_equal "#{@a.name} > #{@a1.name}", @a1.path
+    assert_equal "#{@a.name} > #{@a1.name} > #{@a1a.name}", @a1a.path
+    
+    assert_equal [
+      "#{@a.name}",
+      "#{@a.name} > #{@a1.name}",
+      "#{@a.name} > #{@a1.name} > #{@a1a.name}",
+      "#{@a.name} > #{@a2.name}"
+    ], Category.of_type("A").all.map(&:path)
+  end
+end

data/test/unit/models/category_type_test.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class CategoryTypeTest < ActiveSupport::TestCase
+  def test_create
+    category_type = CategoryType.new(:name => "Test")
+    assert category_type.save
+  end
+end

data/test/unit/models/connector_test.rb

@@ -0,0 +1,152 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class ConnectorTest < ActiveSupport::TestCase
+  
+  def test_container_is_required
+    connector = Factory.build(:connector, :container => nil)
+    assert_not_valid connector
+    assert_has_error_on connector, :container
+  end
+  
+  def test_find_by_block
+    foo = Factory(:html_block, :name => "foo")
+    bar = Factory(:html_block, :name => "bar")
+    Factory(:connector, :connectable => foo, :connectable_version => foo.version)
+    blocks = Connector.for_connectable(foo).map(&:connectable)
+    assert blocks.include?(foo)
+    assert !blocks.include?(bar)
+  end
+  
+  def test_only_find_connectors_for_a_block_that_match_the_current_version
+    @foo = Factory(:html_block, :name => "foo")
+    @foo.update_attribute(:name, "foo v2")
+    @bar = Factory(:html_block, :name => "bar")
+    @con = Factory(:connector, :connectable => @foo)
+    @con.update_attribute(:connectable_version, 99)
+    reset(:con)
+    assert_raise(ActiveRecord::RecordNotFound) { @con.current_connectable }
+  end
+  
+  def test_only_find_connectors_for_the_current_version_of_the_page
+    @page = Factory(:page, :section => root_section)
+    @connector = Factory(:connector, :page => @page)
+    @page.update_attributes(:name => "Updated")
+    assert_equal 1, @page.reload.connectors.for_page_version(@page.version).count
+  end
+  
+  def test_blocks_not_deleted_when_connector_is_not_deleted
+    b = Factory(:html_block)
+    c = Factory(:connector, :connectable => b)
+    connector_count = Connector.count
+    c.destroy
+    assert_decremented connector_count, Connector.count
+    assert !HtmlBlock.find_by_id(b.id).nil?
+  end
+  
+  def test_re_order_blocks_within_a_container
+    page = Factory(:page)
+    one = Factory(:connector, :page => page, :container => "foo")
+    two = Factory(:connector, :page => page, :container => "foo")
+    three = Factory(:connector, :page => page, :container => "foo")
+    
+    two.reload.move_up
+    assert_equal [two, one, three].map(&:id),
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all.map(&:id)
+    
+    two.reload.move_down
+    assert_equal [one, two, three],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+    
+    three.reload.move_to_top
+    assert_equal [three, one, two],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+    
+    one.reload.move_to_bottom
+    assert_equal [three, two, one],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+  end
+  
+  def test_connectable_with_deleted
+    @page = Factory(:page)
+    @block = Factory(:html_block, :name => "Deleted", 
+      :connect_to_page_id => @page.id,
+      :connect_to_container => "main",
+      :publish_on_save => "true")
+    
+    reset(:page, :block)
+    @block.destroy
+    
+    reset(:page)
+
+    log_table_without_stamps Connector
+    
+    assert_nil @page.connectors.for_page_version(2).first.connectable
+    
+    c = @page.connectors.for_page_version(2).first.connectable_with_deleted
+    assert !c.nil?
+    assert_equal @block.id, c.id
+    assert_equal @block.name, c.name
+    assert_equal 1, c.version
+  end
+
+  def test_connector_should_be_copied_when_it_has_a_connectable
+    @page = Factory(:page)
+    @block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "main")
+
+    conn = Connector.new
+    conn.connectable = @block
+    assert(conn.connectable, "Check the assumption there is connectable.")
+    assert_equal(false, conn.connectable.draft.deleted?, "Check the assumption that the draft is not-deleted.")
+
+    assert(conn.should_be_copied?, "Verifes that normally a connector should be copied.")
+  end
+
+  def test_connector_shouldnt_copy_when_its_connectable_is_nil
+    conn = Connector.new
+    assert_nil(conn.connectable, "Check assumption that connectable is nil.")
+
+    assert_equal false, conn.should_be_copied?, "Shouldn't copy when a connector isn't connected to anything."
+  end
+
+  def test_connector_should_copy_when_its_latest_draft_is_deleted
+    @page = Factory(:page)
+    @block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "main")
+
+    @block.destroy
+
+    conn = Connector.new
+    conn.connectable = @block
+
+    assert_equal true, @block.draft.deleted?, "Check assumption that latest draft of this block is 'deleted'."
+    assert_equal false, conn.should_be_copied?, "Should not copy when latest draft is deleted."
+
+  end
+
+  def test_connector_should_copy_even_if_connectable_doesnt_have_drafts
+    @page = Factory(:page)
+    @block = Portlet.create!(:name => "Stuff")
+
+    conn = Connector.new
+    conn.connectable = @block
+
+    assert_equal false, @block.respond_to?(:draft), "Check assumption that portlets do not respond to draft method."
+    assert_equal true, conn.should_be_copied?, "Should not copy when latest draft is deleted."
+
+  end
+  
+  def test_connector_with_file_block_status
+    @page = Factory(:page)
+    @file = Factory(:image_block, :connect_to_page_id => @page.id, :connect_to_container => "main", :publish_on_save => true)
+    @page.reload
+    
+    assert @file.live?
+    assert @page.connectors.last.live?
+    
+    @file.update_attributes(:name => "Something Else")
+    @page.reload
+
+    assert !@file.live?
+    assert !@page.connectors.last.live?    
+  end  
+  
+end

data/test/unit/models/content_type_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+# Sample Model for testing naming/model classes
+class Kindness < ActiveRecord::Base
+  acts_as_content_block
+end
+
+class ContentTypeTest < ActiveSupport::TestCase
+  def setup
+    @c = ContentType.new(:name => "HtmlBlock")
+  end
+
+  def test_model_class
+    assert_equal HtmlBlock, @c.model_class
+  end
+
+  def test_display_name
+    assert_equal "Text", @c.display_name
+  end
+
+  def test_display_name_plural
+    assert_equal "Text", @c.display_name_plural
+  end
+
+  def test_content_block_type
+    assert_equal "html_blocks", @c.content_block_type
+  end
+
+  test "find_by_key handles names that end with s correctly" do
+    ContentType.create!(:name => "Kindness", :group_name => "Anything")
+
+    ct = ContentType.find_by_key("kindness")
+    assert_not_nil ct
+    assert_equal "Kindness", ct.display_name
+  end
+
+  test "calculate the model_class name with s" do
+    ct = ContentType.new(:name=>"Kindness")
+    assert_equal Kindness, ct.model_class
+  end
+
+
+end
+

data/test/unit/models/email_page_portlet_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class EmailPagePortletTest < ActiveSupport::TestCase
+
+  def test_default_template_path
+    assert_equal "portlets/email_page/render", EmailPagePortlet.default_template_path
+  end
+
+  def test_default_template
+    assert_equal File.read(File.join(Rails.root, "app/views/portlets/email_page/render.html.erb")), EmailPagePortlet.default_template
+  end
+
+end
+

data/test/unit/models/file_block_test.rb

@@ -0,0 +1,211 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class FileBlockTest < ActiveSupport::TestCase
+  def setup
+    #@file is a mock of the object that Rails wraps file uploads in
+    @file = file_upload_object(:original_filename => "foo.jpg",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "01010010101010101")
+    @file_block = Factory.build(:file_block, :attachment_file => @file, :attachment_section => root_section, :attachment_file_path => "/test.jpg", :publish_on_save => true)
+  end
+  
+  def test_attachment_is_required
+    @file_block.attachment_file = nil
+    assert !@file_block.valid?
+    assert_equal "You must upload a file", @file_block.errors.on(:attachment_file)
+  end
+  
+  def test_attachment_file_path_is_required
+    @file_block.attachment_file_path = nil
+    assert !@file_block.valid?
+    assert_equal "File Name is required for attachment", @file_block.errors.on(:attachment_file_path)
+  end
+  
+  def test_no_leading_slash_in_file_path
+    @file_block.attachment_file_path = "test.jpg"
+    assert @file_block.save
+    assert_equal "/test.jpg", @file_block.path
+  end
+  
+  def test_create_attachment
+    assert @file_block.save
+    assert !@file_block.attachment.nil?
+    assert "image/jpeg", @file_block.attachment.file_type
+    assert_equal "/test.jpg", @file_block.path
+    assert_equal 1, @file_block.attachment_version
+    assert_equal root_section, @file_block.attachment.section
+  end
+  
+  def test_reverting
+    assert @file_block.save
+    assert "/test.jpg", @file_block.attachment_file_path
+    assert "01010010101010101", File.read(@file_block.attachment.full_file_location)
+    
+    attachment_id = @file_block.attachment_id
+    new_file = file_upload_object(:original_filename => "foo.jpg",
+      :content_type => "image/jpeg", :rewind => true,
+      :size => "99", :read => "10100101010101010")
+    
+    @file_block.update_attributes(:attachment_file => new_file, :publish_on_save => true)
+    reset(:file_block)
+    
+    assert @file_block.save
+    assert 2, @file_block.version
+    assert attachment_id, @file_block.attachment_id
+    assert 2, @file_block.attachment_version    
+    assert "/test.jpg", @file_block.attachment_file_path
+    assert "10100101010101010", File.read(@file_block.attachment.full_file_location)
+    
+    @file_block.revert_to(1)
+    reset(:file_block)
+
+    assert 2, @file_block.version
+    assert 3, @file_block.draft.version
+    assert attachment_id, @file_block.attachment_id
+    assert 2, @file_block.attachment_version
+    assert 3, @file_block.draft.attachment_version
+    assert "/test.jpg", @file_block.attachment_file_path
+    assert "01010010101010101", File.read(@file_block.attachment.full_file_location)
+    assert "10100101010101010", File.read(@file_block.as_of_draft_version.attachment.full_file_location)
+    
+  end
+  
+end
+
+class UpdatingFileBlockTest < ActiveSupport::TestCase
+  def setup
+    @file_block = Factory(:file_block,
+      :attachment_section => root_section,
+      :attachment_file_path => "/test.jpg",
+      :attachment_file => mock_file(:read => "original"),
+      :name => "Test",
+      :publish_on_save => true)
+    reset(:file_block)
+    @attachment = @file_block.attachment
+  end
+  
+  def test_change_attachment_file_name
+    attachment_version = @attachment.version
+    file_attachment_version = @file_block.attachment_version
+    attachment_version_count = Attachment::Version.count
+    
+    assert @file_block.update_attributes(
+      :attachment_file_path => "test_new.jpg",
+      :attachment_file => nil,
+      :publish_on_save => true)
+    
+    assert_incremented attachment_version, @attachment.reload.version
+    assert_incremented file_attachment_version, @file_block.attachment_version
+    assert_incremented attachment_version_count, Attachment::Version.count
+  end  
+  
+  def test_change_attachment_section
+    attachment_version_count = Attachment::Version.count
+    file_block_version = @file_block.version
+
+    @section = Factory(:section, :parent => root_section, :name => "New")
+    @file_block.update_attributes!(:attachment_section => @section, :publish_on_save => true)
+
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_incremented file_block_version, @file_block.reload.version
+    assert_equal @section, @file_block.attachment_section
+    assert_equal "/test.jpg", @file_block.attachment.file_path
+    assert_equal "test.jpg", @file_block.attachment.file_name
+  end  
+  
+  def test_change_attachment_data_with_save
+    attachment_count = Attachment.count
+    attachment_version_count = Attachment::Version.count
+    file_block_version = @file_block.draft.version
+
+    @section = Factory(:section, :parent => root_section, :name => "New")
+    @file_block.update_attributes!(:attachment_file => mock_file(:read => "new"))
+    
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_incremented file_block_version, @file_block.draft.version
+    assert_equal "new", open(@file_block.as_of_draft_version.attachment.full_file_location){|f| f.read}
+    assert !@file_block.live?
+    assert !@file_block.attachment.live?
+  end
+  
+  def test_change_attachment_data_with_save_and_publish
+    attachment_count = Attachment.count
+    attachment_version_count = Attachment::Version.count
+    file_block_version = @file_block.version
+
+    @section = Factory(:section, :parent => root_section, :name => "New")
+    @file_block.update_attributes!(:attachment_file => mock_file(:read => "new"), :publish_on_save => true)
+    
+    assert_equal attachment_count, Attachment.count
+    assert_incremented attachment_version_count, Attachment::Version.count
+    assert_incremented file_block_version, @file_block.reload.version
+    assert_equal "new", open(@file_block.attachment.full_file_location){|f| f.read}
+    assert @file_block.published?
+    assert @file_block.attachment.published?
+  end
+  
+  def test_no_changes_to_the_attachment
+    attachment_count = Attachment.count
+    attachment_version_count = Attachment::Version.count
+    file_block_version = @file_block.version
+    
+    @file_block.update_attributes!(:name => "Test 2", :publish_on_save => true)
+    
+    assert_equal attachment_count, Attachment.count
+    assert_equal attachment_version_count, Attachment::Version.count
+    assert_incremented file_block_version, @file_block.reload.version
+    assert_equal "Test 2", @file_block.name
+  end
+  
+end
+
+class ViewingOlderVersionOfFileTest < ActiveSupport::TestCase
+  
+  def test_that_it_shows_the_correct_content
+    @file1 = mock_file(:content_type => "text/plain", :read => "v1")      
+    @file2 = mock_file(:content_type => "text/plain", :read => "v2")
+    @file_block = Factory(:file_block, :attachment_file => @file1, :attachment_file_path => "/test.txt", :attachment_section => root_section)
+    @file_block.update_attributes(:attachment_file => @file2)
+    #reset(:file_block)            
+    assert_equal "v1", open(@file_block.as_of_version(1).attachment.full_file_location){|f| f.read}
+  end
+  
+end
+
+class ExistingFileBlockTest < ActiveSupport::TestCase
+  def setup
+    @file_block = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/test.txt", :attachment_section => root_section)
+  end
+  
+  def test_archiving
+    assert @file_block.update_attributes(:archived => true)
+    assert @file_block.attachment.archived?
+  end
+  
+  def test_destroy
+    @file_block.destroy      
+    assert_nil Attachment.find_live_by_file_path("/test.txt")
+  end
+end
+
+class ExistingFileBlocksTest < ActiveSupport::TestCase
+  def setup
+    @one = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/one.txt", :attachment_section => root_section)
+    @two = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/two.txt", :attachment_section => root_section)
+    @section = Factory(:section, :name => "A")
+    @a1 = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/a/1.txt", :attachment_section => @section)
+    @a2 = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/2.txt", :attachment_section => @section)
+    #reset(:one, :two, :a1, :a2)
+  end
+  
+  def test_find_blocks_in_root_section
+    assert_equal [@one, @two], FileBlock.by_section(root_section).all(:order => "file_blocks.id")
+  end
+  
+  def test_find_blocks_in_sub_section
+    assert_equal [@a1, @a2], FileBlock.by_section(@section).all(:order => "file_blocks.id")
+  end
+end
+
+

data/test/unit/models/group_test.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class GroupTest < ActiveSupport::TestCase
+  def test_valid
+    assert Factory.build(:group).valid?
+  end
+end

data/test/unit/models/html_block_test.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class HtmlBlockTest < ActiveSupport::TestCase
+  def test_create    
+    @page = Factory(:page)
+    @html_block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "test")
+    assert_equal 1, @page.reload.connectors.count
+    assert_equal @page, @html_block.connected_page
+    assert_equal @page.id, @html_block.connect_to_page_id
+    assert_equal "test", @html_block.connect_to_container
+  end
+  
+  def test_versioning
+    assert HtmlBlock.versioned?
+    
+    @html_block = Factory(:html_block, :name => "Original Value")
+    assert_equal @html_block, @html_block.versions.last.html_block
+
+    # Updates should make a new version
+    assert @html_block.update_attributes(:name => "Something Different")
+    assert_equal @html_block, @html_block.versions.last.html_block
+    assert_equal "Something Different", @html_block.versions.last.name
+    assert_equal "Something Different", @html_block.name
+    assert_equal "Original Value", @html_block.versions.first.name
+  
+    # Updating with no changes should not generate a new version
+    html_block_version_count = @html_block.versions.count
+    @html_block.update_attributes(:name => "Something Different")
+    assert_equal html_block_version_count, @html_block.versions.count
+    
+    # deleting should create a new version
+    html_block_count = HtmlBlock.count_with_deleted
+    html_block_version_count = @html_block.versions.count
+    assert !@html_block.deleted?
+    
+    @html_block.destroy    
+    
+    assert_equal html_block_count, HtmlBlock.count_with_deleted
+    assert_incremented html_block_version_count, @html_block.versions.count
+    assert @html_block.deleted?
+    
+  end
+  
+  def test_reverting
+    # We need a block with a version that was created in the past
+    @v1_created_at = Time.zone.now - 5.days
+    @html_block = Factory(:html_block, :name => "Version One", :created_at => @v1_created_at)
+    
+    # Make the version be created in the past as well
+    v1 = @html_block.versions.last
+    v1.created_at = @v1_created_at
+    v1.save
+
+    # Make a new version
+    @html_block.update_attributes(:name => "Version Two")
+    @v2_created_at = @html_block.versions.last.created_at
+
+    assert_equal "Version Two", @html_block.name
+    assert_equal @v1_created_at.to_i, @html_block.find_version(1).created_at.to_i
+    assert_equal @v2_created_at.to_i, @html_block.find_version(2).created_at.to_i
+    
+    @html_block.revert_to 1
+    @html_block.reload
+
+    assert_equal 3, @html_block.draft.version
+    assert_equal "Version One", @html_block.name
+    assert_equal @v1_created_at.to_i, @html_block.find_version(1).created_at.to_i
+    assert_equal @v2_created_at.to_i, @html_block.find_version(2).created_at.to_i
+    assert @html_block.find_version(3).created_at.to_i >= @v2_created_at.to_i
+    assert @v1_created_at.to_i, @html_block.created_at.to_i
+    
+    # version is required for revert_to
+    html_block_version_count = HtmlBlock::Version.count
+    assert_raise "Version parameter missing" do
+      @html_block.revert_to nil
+    end
+    assert_equal html_block_version_count, HtmlBlock::Version.count
+     
+    html_block_version_count = HtmlBlock::Version.count
+    assert_raise "Could not find version 42" do
+      @html_block.revert_to 42
+    end
+    assert_equal html_block_version_count, HtmlBlock::Version.count 
+  end
+  
+  def test_previous_version
+    @html_block = Factory(:html_block, :name => "V1")
+    @html_block.update_attributes(:name => "V2")
+    @version = @html_block.as_of_version 1
+    
+    assert_equal HtmlBlock, @version.class
+    assert_equal "V1", @version.name
+    assert_equal 1, @version.version
+    assert_equal @html_block.id, @version.id
+    
+    # We can't freeze the version because we need to be able to load assocations
+    assert !@version.frozen?
+    assert !@version.live?
+    assert !@html_block.live?
+  end
+  
+end