browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/mock_file_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class MockFileTest < ActiveSupport::TestCase
-
-  def setup
-
-  end
-
-  def teardown
-
-  end
-
-
-  test "mock files can have data read from them" do
-    file = mock_file()
-    assert_not_nil file.path
-    assert_equal "", open(file.path) { |f| f.read }
-  end
-end

data/test/unit/models/attachment_test.rb

@@ -1,160 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class AttachmentTest < ActiveSupport::TestCase
-
-    def setup
-      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
-
-    end
-
-    def test_creating_an_attachment_with_no_file
-      attachment = Cms::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 = @file
-      attachment = Cms::Attachment.new(:temp_file => file, :file_path => "/sample_upload.txt", :section => root_section)
-
-      attachment.save!
-      assert_equal "sample_upload.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
-      attachment = Cms::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 = Cms::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
-    end
-
-    def test_updating_a_new_file_should_change_the_file_location
-      attachment = Cms::Attachment.create!(:temp_file => @file, :file_path => "/foo.txt", :section => root_section)
-
-      reloaded_attachment = Cms::Attachment.find(attachment.id)
-      original_file_location = attachment.file_location
-      file = file_upload_object(:original_filename => "second_upload.txt", :content_type => "text/plain")
-      reloaded_attachment.update_attributes(:temp_file => file)
-      assert_equal 2, reloaded_attachment.draft.version
-      assert_equal "/foo.txt", reloaded_attachment.as_of_draft_version.file_path, "Updating the file itself should also update the name of the file. (Note:This might just be an invalid test)"
-      assert_equal "foo.txt", reloaded_attachment.as_of_draft_version.file_name
-      assert_not_equal original_file_location, reloaded_attachment.as_of_draft_version.file_location
-      assert_equal "This is a second file.", open(reloaded_attachment.as_of_draft_version.full_file_location) { |f| f.read }
-    end
-
-    def test_find_live_by_file_path
-      file = @file
-      attachment = Cms::Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
-      attachment.save!
-      assert !attachment.published?, "Attachment should not be published"
-      assert_nil Cms::Attachment.find_live_by_file_path("/foo.txt")
-
-      attachment.publish
-      assert attachment.reload.published?, "Attachment should be published"
-      assert_equal attachment, Cms::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), Cms::Attachment.find_live_by_file_path("/foo.txt")
-    end
-
-
-    test "If an uploaded file has no detectable content type (i.e. markdown) then assign it the 'unknown' type" do
-      mock_file = mock()
-      mock_file.expects(:content_type).returns(nil)
-      atk = Cms::Attachment.new(:temp_file => mock_file)
-      atk.extract_file_type_from_temp_file
-
-      assert_equal Cms::Attachment::UNKNOWN_MIME_TYPE, atk.file_type
-    end
-  end
-
-  class Cms::Attachment::SectionTest < ActiveSupport::TestCase
-
-    def setup
-      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
-      @attachment = Cms::Attachment.create!(:temp_file => @file, :file_path => "/foo.txt", :section => root_section)
-      @attachment = Cms::Attachment.find(@attachment.id) # Force reload
-    end
-
-    test "Setting the section on an attachment persists that section" do
-      assert_equal root_section, @attachment.section, "Should be associated with the root section"
-    end
-
-    test "Replacing an existing section should update it" do
-      new_section = Factory(:section)
-      @attachment.section = new_section
-      @attachment.save!
-      @attachment = Cms::Attachment.find(@attachment.id) # Force reload
-      assert_equal new_section, @attachment.section
-    end
-  end
-
-  class AttachmentRelations < ActiveSupport::TestCase
-
-    def setup
-      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
-      @attachment = Attachment.new(:temp_file => @file, :file_path => "/bar.txt", :section => root)
-      @attachment.save!
-    end
-
-    test "#section= assigns a parent to a given attachment" do
-      a = Attachment.new
-      a.section = root
-      assert_equal root, a.section
-    end
-
-    test "Attachments should be associated with a section" do
-      assert_not_nil @attachment.section_node
-      assert_not_nil @attachment.section_node.parent
-      assert_equal root, @attachment.section
-    end
-
-    test "Attachment should be unpublished and unfindable" do
-      assert !@attachment.published?, "Attachment should not be published"
-      assert_nil Attachment.find_live_by_file_path("/foo.txt")
-    end
-
-    test "Publishing an attachment should make it findable" do
-      @attachment.publish
-      assert @attachment.reload.published?, "Attachment should be published"
-      assert_equal @attachment, Attachment.find_live_by_file_path("/bar.txt")
-    end
-
-    test "Changing but not republishing an attachment should keep old version live" do
-      @attachment.publish
-      assert_equal @root, @attachment.section
-      @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("/bar.txt")
-    end
-
-    test "Updating the section" do
-      new_section = Factory(:section, :name => "New")
-      @attachment.update_attributes!(:section => new_section)
-      assert_equal new_section, @attachment.section
-    end
-    private
-
-    def root
-      @root ||= Factory :root_section
-    end
-  end
-end

data/test/unit/models/category_test.rb

@@ -1,40 +0,0 @@
-require '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}"
-    ], Cms::Category.of_type("A").all.map(&:path)
-  end
-end

data/test/unit/models/category_type_test.rb

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

data/test/unit/models/connector_test.rb

@@ -1,152 +0,0 @@
-require '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 = Cms::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 = Cms::Connector.count
-    c.destroy
-    assert_decremented connector_count, Cms::Connector.count
-    assert !Cms::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 Cms::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 = Cms::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 = Cms::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 = Cms::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 = Cms::Portlet.create!(:name => "Stuff")
-
-    conn = Cms::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_group_test.rb

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

@@ -1,177 +0,0 @@
-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
-
-# For testing find_by_key with pluralization
-class Person < ActiveRecord::Base
-  acts_as_content_block
-end
-
-module Cms
-
-  class FindByKeyTest < ActiveSupport::TestCase
-
-    test "ActiveSupport#classify automatically singularizes" do
-      assert_equal "Person", "people".tableize.classify
-      assert_equal "people", "people".tableize
-
-    end
-
-    test "#find_by_key with irregular pluralization" do
-      Factory(:content_type, :name => "Person")
-
-      type = Cms::ContentType.find_by_key("people")
-      assert_not_nil type
-      assert_equal "Person", type.display_name
-
-    end
-  end
-end
-