browsercms 3.3.4 → 3.4.0.rc1

data/test/unit/models/content_type_group_test.rb

@@ -0,0 +1,26 @@
+require "test_helper"
+
+module Cms
+  class ContentTypeGroupTest < ActiveSupport::TestCase
+
+    def setup
+      @type1 = ContentType.create!(:name => "Cms::Block", :group_name => "A")
+      @type2 = ContentType.create!(:name => "Cms::Block", :group_name => "B")
+    end
+
+    test ".menu_list returns all groups" do
+      groups = ContentTypeGroup.menu_list
+
+      assert_equal 2, groups.size
+      assert_equal ["A", "B"], groups.map {|g| g.name }
+    end
+
+    test "#types returns all types ordered by position" do
+      @type3 = ContentType.create!(:name => "Cms::Block", :group_name => "A")
+
+      group = ContentTypeGroup.where(:name=>"A").first
+      assert_equal [@type1, @type3], group.types
+    end
+
+  end
+end

data/test/unit/models/content_type_test.rb

@@ -0,0 +1,150 @@
+require '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
+
+module Cms
+  class NamespacedBlock < ActiveRecord::Base
+    acts_as_content_block
+  end
+end
+
+class Unnamespaced < ActiveRecord::Base
+  acts_as_content_block
+end
+
+class Widget < ActiveRecord::Base
+  acts_as_content_block
+end
+
+module BcmsStore
+  class Engine < Rails::Engine
+  end
+  class Widget < ActiveRecord::Base
+    acts_as_content_block
+  end
+end
+
+module Cms
+
+  class ContentTypeTest < ActiveSupport::TestCase
+    def setup
+      @c = Cms::ContentType.new(:name => "ReallyLongNameClass")
+      @unnamespaced_type = Cms::ContentType.create!(:name => "Unnamespaced", :group_name => "Core")
+    end
+
+
+    test "#key" do
+      assert_equal "really_long_name_class", @c.key
+    end
+
+    test "#display_name for blocks from modules" do
+      assert_equal "Widget", Cms::ContentType.new(:name => "BcmsStore::Widget").display_name
+      assert_equal "Widget", BcmsStore::Widget.display_name
+    end
+
+    test "display_name for non-Cms classes" do
+      assert_equal "String", Cms::ContentType.new(:name => "String").display_name
+    end
+
+    test "#form for unnamespaced blocks" do
+      widget_type = Cms::ContentType.create!(:name => "Widget", :group_name => "Core")
+      assert_equal "cms/widgets/form", widget_type.form
+    end
+
+    test "template_path" do
+      assert_equal "cms/widgets/render", Widget.template_path
+    end
+
+    test "template_path for modules" do
+      assert_equal "bcms_store/widgets/render", BcmsStore::Widget.template_path
+    end
+
+    test "find_by_key checks multiple namespaces" do
+      assert_equal @unnamespaced_type, Cms::ContentType.find_by_key("Unnamespaced")
+    end
+
+    test "model_resource_name" do
+      assert_equal "really_long_name_class", @c.model_class_form_name
+    end
+
+    test "Project specific routes should be still be namespaced under cms_" do
+      assert_equal "main_app.cms_unnamespaced", @unnamespaced_type.route_name
+    end
+
+    test "route_name removes cms_ as prefix (no longer needed for engines)" do
+      content_type = Cms::ContentType.new(:name => "Cms::NamespacedBlock")
+      assert_equal "namespaced_block", content_type.route_name
+    end
+
+    test "engine_for using Class" do
+      EngineHelper.decorate(Unnamespaced)
+      assert_equal "main_app", Unnamespaced.engine_name
+    end
+
+    test "engine_name for Cms engine" do
+      cms_namespace = Cms::ContentType.new(:name => "Cms::NamespacedBlock")
+      assert_equal "cms", cms_namespace.engine_name
+    end
+
+    test "path_elements for Cms engine" do
+      cms_namespace = Cms::ContentType.new(:name => "Cms::NamespacedBlock")
+      assert_equal [Cms::NamespacedBlock], cms_namespace.path_elements
+    end
+
+    test "path_elements for an app ContentType" do
+      assert_equal ["cms", Unnamespaced], @unnamespaced_type.path_elements
+    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
+      Cms::ContentType.create!(:name => "Kindness", :group_name => "Anything")
+
+      ct = Cms::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 = Cms::ContentType.new(:name => "Kindness")
+      assert_equal Kindness, ct.model_class
+    end
+
+    test "Form for Blocks with Engines" do
+      engine_type = Cms::ContentType.new(:name => "BcmsStore::Widget")
+      assert_equal true, engine_type.engine_exists?
+      assert_equal "bcms_store/widgets/form", engine_type.form
+    end
+
+  end
+end
+

data/test/unit/models/dynamic_views_test.rb

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

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

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