browsercms 3.1.5 → 3.3.0.beta

data/test/unit/models/content_type_test.rb

@@ -1,56 +0,0 @@
-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 ReallyLongNameClass < ActiveRecord::Base
-  acts_as_content_block
-
-  def self.display_name
-    "Short"
-  end
-
-  def self.display_name_plural
-    "Shorteez"
-  end
-end
-
-class ContentTypeTest < ActiveSupport::TestCase
-  def setup
-    @c = ContentType.new(:name => "ReallyLongNameClass")
-  end
-
-  def test_model_class
-    assert_equal ReallyLongNameClass, @c.model_class
-  end
-
-  test "creating self.display_name on content block will set display_name on content type" do
-    assert_equal "Short", @c.display_name
-  end
-
-  test "creating self.display_name_plural on content block will set display_name_plural on content type" do
-    assert_equal "Shorteez", @c.display_name_plural
-  end
-
-  def test_content_block_type
-    assert_equal "really_long_name_classes", @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

@@ -1,14 +0,0 @@
-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

@@ -1,230 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-class FileBlockTest < ActiveSupport::TestCase
-
-  def setup
-    @root = Factory :root_section
-    #@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, :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, @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 file_block_version, @file_block.reload.version
-    assert_incremented attachment_version_count, Attachment::Version.count
-    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 => Factory(: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, :name=>"One")
-    @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
-
-   test "searchable?" do
-    assert FileBlock.searchable?
-  end
-
-  test "search by name" do
-    assert_equal [@one], FileBlock.search("one")
-  end
-
-  test "search by section" do
-    options = {}
-    options[:page] = 1
-    options[:include] = { :attachment =>  :section_node }
-    options[:conditions] = ["section_nodes.ancestry = ?", root_section.ancestry_path]
-
-    assert_equal [@one, @two], FileBlock.search("").paginate(options)
-  end
-end
-
-

data/test/unit/models/group_test.rb

@@ -1,13 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-class GroupTest < ActiveSupport::TestCase
-  def test_valid
-    assert Factory.build(:group).valid?
-  end
-
-  test "Find guest group via method" do
-    expected = Group.find_by_code(Group::GUEST_CODE)
-    assert_not_nil expected, "Validates that our fixture code is loading a guest user into the database."
-    assert_equal expected, Group.guest
-  end
-end

data/test/unit/models/html_block_test.rb

@@ -1,102 +0,0 @@
-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

data/test/unit/models/link_test.rb

@@ -1,52 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-class LinkTest < ActiveSupport::TestCase
-
-  def setup
-    @link = Factory(:link)
-    @another_link = Factory(:link)
-  end
-
-  def test_create
-    assert Factory.build(:link).valid?
-    assert !Factory.build(:link, :name => "").valid?
-  end
-
-  test "draft_version is stored on pages" do
-    assert_equal 1, @link.version
-    assert_equal 1, @link.latest_version
-  end
-
-  test "#update increments the latest_version" do
-    @link.name = "New"
-    @link.save!
-    @link.reload
-
-    assert_equal 1, @link.version
-    assert_equal 2, @link.latest_version
-
-    assert_equal 1, @another_link.reload.latest_version, "Should only update its own version, not other tables"
-  end
-
-  test "live?" do
-    assert @link.live?
-  end
-
-  test "updating makes it not live" do
-    @link.update_attributes(:name => "New")
-    @link.reload
-    refute @link.live?
-
-    @link.publish!
-    @link.reload
-    assert @link.live?
-  end
-
-  test "live? as_of_version" do
-    @link.update_attributes(:name => "New")
-    @link.publish!
-
-    v1 = @link.as_of_version(1)
-    assert v1.live?
-  end
-end