browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/models/dynamic_views_test.rb

@@ -1,36 +0,0 @@
-require "test_helper"
-
-class BasicTemplate < Cms::DynamicView
-
-end
-
-class Cms::DynamicViewsTest < ActiveSupport::TestCase
-
-  def setup
-
-  end
-
-  def teardown
-
-  end
-
-  test "version_foreign_key" do
-    assert_equal :original_record_id, Cms::PageTemplate.version_foreign_key
-  end
-
-  test "resource_name works for non-namespaced templates" do
-    assert_equal "basic_templates", BasicTemplate.resource_name
-  end
-
-  test "Engine" do
-    assert_equal "cms", Cms::DynamicView.engine
-    assert_equal "cms", Cms::PageTemplate.engine
-    assert_equal "cms", Cms::PagePartial.engine
-  end
-
-  test "path_elements" do
-    assert_equal [Cms::PageTemplate], Cms::PageTemplate.path_elements
-    assert_equal [Cms::PagePartial], Cms::PagePartial.path_elements
-
-  end
-end

data/test/unit/models/email_page_portlet_test.rb

@@ -1,20 +0,0 @@
-require '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.expand_path(File.join(engine_root_dir, "app/views/portlets/email_page/render.html.erb"))), EmailPagePortlet.default_template
-  end
-
-  private
-
-  # Rails.root won't work, since that's the dummy app. So find the root director of this project.
-  def engine_root_dir
-    File.join(__FILE__, "..", "..", "..", "..")
-  end
-end
-

data/test/unit/models/file_block_test.rb

@@ -1,246 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class FileBlockTest < ActiveSupport::TestCase
-
-    def setup
-      @root = Factory :root_section
-      #@file is a mock of the object that Rails wraps file uploads in
-      @uploaded_file = file_upload_object(:original_filename => "version1.txt", :content_type => "text/plain")
-      @file_block = Factory.build(:file_block, :attachment_file => @uploaded_file, :attachment_section => @root, :attachment_file_path => "/test.jpg", :publish_on_save => true)
-    end
-
-    def test_table_name
-      assert_equal Cms::Namespacing.prefix("file_blocks"), Cms::FileBlock.table_name
-    end
-
-    test "Saving should also save attachment." do
-      @file_block.save!
-      assert_not_nil @file_block.attachment
-
-      found = Cms::FileBlock.find(@file_block)
-      assert_not_nil found.attachment
-    end
-
-    test "Saving should save a version with the correct pointer to its attachment" do
-      @file_block.save!
-      attachment = @file_block.attachment
-      assert_equal attachment.id, @file_block.versions[0].attachment_id
-      assert_equal attachment.version, @file_block.versions[0].attachment_version
-    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[:attachment_file].first
-    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[:attachment_file_path].first
-    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_equal "v1", File.read(@file_block.attachment.full_file_location)
-
-      attachment_id = @file_block.attachment_id
-      new_file = file_upload_object(:original_filename => "version2.txt")
-
-      @file_block.update_attributes(:attachment_file => new_file, :publish_on_save => true)
-      reset(:file_block)
-
-      assert @file_block.save
-      assert_equal 2, @file_block.version
-      assert_equal attachment_id, @file_block.attachment_id
-      assert_equal 2, @file_block.attachment_version
-      assert_equal "/test.jpg", @file_block.attachment_file_path
-      assert_equal "v2", File.read(@file_block.attachment.full_file_location)
-
-      @file_block.revert_to(1)
-      reset(:file_block)
-
-      assert_equal 2, @file_block.version
-      assert_equal 3, @file_block.draft.version
-      assert_equal attachment_id, @file_block.attachment_id
-      assert_equal 2, @file_block.attachment_version
-      assert_equal 3, @file_block.draft.attachment_version
-      assert_equal "/test.jpg", @file_block.attachment_file_path
-      assert "v1", File.read(@file_block.attachment.full_file_location)
-      assert "v1", 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(),
-                            :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 = Cms::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, Cms::Attachment::Version.count
-    end
-
-    def test_change_attachment_section
-      attachment_version_count = Cms::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, Cms::Attachment::Version.count
-      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 = Cms::Attachment.count
-      attachment_version_count = Cms::Attachment::Version.count
-      file_block_version = @file_block.draft.version
-
-      @file_block.update_attributes!(:attachment_file => mock_file(:original_filename => "version2.txt"))
-
-      assert_equal attachment_count, Cms::Attachment.count
-      assert_incremented attachment_version_count, Cms::Attachment::Version.count
-      assert_incremented file_block_version, @file_block.draft.version
-      assert_equal "v2", 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 = Cms::Attachment.count
-      attachment_version_count = Cms::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(:original_filename => "version2.txt"), :publish_on_save => true)
-
-      assert_equal attachment_count, Cms::Attachment.count
-      assert_incremented attachment_version_count, Cms::Attachment::Version.count
-      assert_incremented file_block_version, @file_block.reload.version
-      assert_equal "v2", 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 = Cms::Attachment.count
-      attachment_version_count = Cms::Attachment::Version.count
-      file_block_version = @file_block.version
-
-      @file_block.update_attributes!(:name => "Test 2", :publish_on_save => true)
-
-      assert_equal attachment_count, Cms::Attachment.count
-      assert_equal attachment_version_count, Cms::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(:original_filename => "version1.txt")
-      @file2 = mock_file(:original_filename => "version2.txt")
-      @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 Cms::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], Cms::FileBlock.by_section(root_section).all(:order => "#{Cms::FileBlock.table_name}.id")
-    end
-
-    def test_find_blocks_in_sub_section
-      assert_equal [@a1, @a2], Cms::FileBlock.by_section(@section).all(:order => "#{Cms::FileBlock.table_name}.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] = ["cms_section_nodes.ancestry = ?", root_section.ancestry_path]
-
-      assert_equal [@one, @two], FileBlock.search("").paginate(options)
-    end
-  end
-end
-

data/test/unit/models/group_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class GroupTest < ActiveSupport::TestCase
-
-  def setup
-    given_there_is_a_guest_group
-  end
-
-  def test_valid
-    assert Factory.build(:group).valid?
-  end
-
-  test "Find guest group via method" do
-    expected = Cms::Group.find_by_code(Cms::Group::GUEST_CODE)
-    assert_not_nil expected
-    assert_equal expected, Cms::Group.guest
-  end
-
-  test "has_permission?" do
-    p1 = Factory(:permission, :name=>"Edit Things")
-    p2 = Factory(:permission, :name=>"Delete things")
-
-    group = Factory.build(:group)
-    group.permissions << p1
-
-    assert group.has_permission?("Edit Things")
-    assert !group.has_permission?("Delete things")
-  end
-end

data/test/unit/models/html_block_test.rb

@@ -1,121 +0,0 @@
-require 'test_helper'
-
-class HtmlBlockTest < ActiveSupport::TestCase
-
-  test "template_path" do
-    assert_equal "cms/html_blocks/render", Cms::HtmlBlock.template_path
-  end
-
-  test "default table_name" do
-    assert_equal Cms::Namespacing.prefix("html_blocks"), Cms::HtmlBlock.table_name
-  end
-
-  test "form" do
-    type = Cms::ContentType.new(:name=>"Cms::HtmlBlock")
-    assert_equal "cms/html_blocks/form", type.form
-  end
-
-  test "save" do
-
-    @block = Cms::HtmlBlock.create!(:name=>"Test")
-  end
-
-  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 Cms::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 = Cms::HtmlBlock.count_with_deleted
-    html_block_version_count = @html_block.versions.count
-    assert !@html_block.deleted?
-    
-    @html_block.destroy    
-    
-    assert_equal html_block_count, Cms::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 = Cms::HtmlBlock::Version.count
-    assert_raise "Version parameter missing" do
-      @html_block.revert_to nil
-    end
-    assert_equal html_block_version_count, Cms::HtmlBlock::Version.count
-     
-    html_block_version_count = Cms::HtmlBlock::Version.count
-    assert_raise "Could not find version 42" do
-      @html_block.revert_to 42
-    end
-    assert_equal html_block_version_count, Cms::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 Cms::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