browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/models/permission_test.rb

@@ -1,10 +0,0 @@
-require 'test_helper'
-
-class PermissionTest < ActiveSupport::TestCase
-  def test_create
-    perm = Factory(:permission, :name => "test")
-    assert !Factory.build(:permission, :name => "").valid?
-    assert !Factory.build(:permission, :name => "test").valid?
-    assert_equal perm, Cms::Permission.named("test").first
-  end
-end

data/test/unit/models/portlet_test.rb

@@ -1,99 +0,0 @@
-require 'test_helper'
-
-# These Portlet classes cannot be defined within the PortletTest class. Something
-# related to the dynamic attributes causes other tests to fail otherwise.
-class NoInlinePortlet < Cms::Portlet
-  render_inline false
-end
-
-class InlinePortlet < Cms::Portlet
-end
-
-class NonEditablePortlet < Cms::Portlet
-  enable_template_editor false
-end
-
-class EditablePortlet < Cms::Portlet
-  enable_template_editor true
-end
-
-
-class PortletTest < ActiveSupport::TestCase
-
-  def setup
-    @portlet = Factory(:portlet)
-
-  end
-
-  test "destroy should mark a portlet as deleted" do
-    @portlet.destroy
-    @portlet.reload!
-    assert_equal true, @portlet.deleted?
-    #Cms::Portlet.find(@portlet.id)
-    #assert_raise(ActiveRecord::RecordNotFound){
-    #  Cms::Portlet.find(@portlet.id)
-    #}
-  end
-
-  test "update_attributes" do
-    @portlet.update_attributes(:b => "whatever")
-    assert_equal "whatever", @portlet.b
-  end
-
-  test "attributes=" do
-    @portlet.attributes=({:b => "b"})
-    assert_equal "b", @portlet.b
-  end
-
-  def test_dynamic_attributes
-    portlet = DynamicPortlet.create(:name => "Test", :foo => "FOO")
-    assert_equal "FOO", Cms::Portlet.find(portlet.id).foo
-    assert_equal "Dynamic Portlet", portlet.portlet_type_name
-  end
-
-  def test_portlets_consistently_load_the_same_number_of_types
-
-    list = Cms::Portlet.types
-    assert list.size > 0
-
-    DynamicPortlet.create!(:name=>"test 1")
-    DynamicPortlet.create!(:name=>"test 2")
-
-    assert_equal list.size, Cms::Portlet.types.size
-  end
-
-
-  test "render_inline" do
-    assert_equal false, NoInlinePortlet.render_inline
-  end
-
-  test "Portlets should default to render_inline is true" do
-    assert InlinePortlet.render_inline
-  end
-
-  test "allow_template_editing" do
-    assert_equal true, EditablePortlet.render_inline
-
-    assert_equal false, NonEditablePortlet.render_inline
-  end
-
-  test "If render_inline is true, should return the value of 'template'" do
-    p = EditablePortlet.new
-    p.template = "<b>CODE HERE</b>"
-
-    assert_equal p.template, p.inline_options[:inline]
-  end
-  test "If render_inline is true, but template is blank, don't render inline" do
-    p = EditablePortlet.new
-
-    p.template = nil
-    assert_equal({}, p.inline_options)
-
-    p.template = ""
-    assert_equal({}, p.inline_options)
-  end
-
-  test "Portlets should be considered 'connectable?, and therefore can have a /usages route.'" do
-    assert Cms::Portlet.connectable?
-  end
-end

data/test/unit/models/sections_test.rb

@@ -1,278 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class SectionTest < ActiveSupport::TestCase
-
-    def setup
-      @root = Factory(:root_section)
-    end
-
-    def test_not_allow_slash_in_name
-      section = Factory.build(:section, :name => "OMG / WTF / BBQ")
-      assert !section.valid?
-      assert_has_error_on section, :name, "cannot contain '/'"
-    end
-
-    test "sections return all child sections of a section" do
-      s = Factory(:public_section)
-      assert_equal [s], s.parent.sections
-    end
-
-    def test_create_sub_section
-      sub = Factory(:section, :name => "Sub Section", :parent => root_section)
-      assert_equal sub, root_section.sections.last
-      assert_equal root_section, sub.parent
-    end
-
-    def test_move_into_another_section
-      foo = Factory(:section, :name => "Foo", :parent => @root)
-      bar = Factory(:section, :name => "Bar", :parent => @root)
-      assert_equal @root, foo.parent
-      assert foo.move_to(bar)
-      assert_equal bar, foo.parent
-    end
-
-    def test_cannot_move_root_section
-      foo = Factory(:section, :name => "Foo", :parent => @root)
-      assert !@root.move_to(foo)
-    end
-
-    def test_find_first_page_or_link_in_section_page
-      @a = Factory(:section, :parent => @root, :name => "A")
-      @a1 = Factory(:section, :parent => @a, :name => "A1")
-      @a1a = Factory(:section, :parent => @a1, :name => "A1a")
-      @foo = Factory(:page, :section => @a1a, :name => "Foo")
-      @b = Factory(:section, :parent => @root, :name => "B")
-
-      assert_equal @foo, @a.first_page_or_link
-      assert_equal @foo, @a1.first_page_or_link
-      assert_equal @foo, @a1a.first_page_or_link
-      assert_nil @b.first_page_or_link
-    end
-
-    def test_find_first_page_or_link_in_section_link
-      @a = Factory(:section, :parent => @root, :name => "A")
-      @a1 = Factory(:link, :section => @a, :name => "A1")
-      @a2 = Factory(:page, :section => @a, :name => "A2")
-
-      assert_equal @a1, @a.first_page_or_link
-
-      @a2.section_node.move_to(@a, 0)
-
-      assert_equal @a2, @a.first_page_or_link
-    end
-
-    def test_find_first_page_or_link_after_delete
-      @a = Factory(:section, :parent => @root, :name => "A")
-      @a1 = Factory(:page, :section => @a, :name => "A1")
-      @a2 = Factory(:page, :section => @a, :name => "A2")
-      @a3 = Factory(:page, :section => @a, :name => "A3")
-      assert_equal @a1, @a.first_page_or_link
-      @a1.destroy
-
-      assert_equal @a2, @a.first_page_or_link
-    end
-
-    def test_find_by_name_path
-      @a = Factory(:section, :parent => root_section, :name => "A")
-      @b = Factory(:section, :parent => @a, :name => "B")
-      @c = Factory(:section, :parent => @b, :name => "C")
-
-      assert_equal root_section, Cms::Section.find_by_name_path("/")
-      assert_equal @a, Cms::Section.find_by_name_path("/A/")
-      assert_equal @b, Cms::Section.find_by_name_path("/A/B/")
-      assert_equal @c, Cms::Section.find_by_name_path("/A/B/C/")
-    end
-
-    def test_section_with_sub_section
-      @section = Factory(:section, :parent => root_section)
-      Factory(:section, :parent => @section)
-
-      assert !@section.empty?
-      assert !@section.deletable?
-
-      section_count = Cms::Section.count
-      assert !@section.destroy
-      assert_equal section_count, Cms::Section.count
-
-    end
-
-    test "sections with pages should not be empty?" do
-      @section = Factory(:section, :parent => @root)
-      Factory(:page, :section => @section)
-
-      assert_equal false, @section.empty?
-    end
-
-    def test_section_with_page_should_not_be_deletable
-      @section = Factory(:section, :parent => @root)
-      Factory(:page, :section => @section)
-
-      assert !@section.deletable?
-
-      section_count = Cms::Section.count
-      assert !@section.destroy
-      assert_equal section_count, Cms::Section.count
-    end
-
-    def test_a_root_section_shouldnt_be_deletable_even_without_children
-
-      assert !root_section.deletable?
-
-      section_count = Cms::Section.count
-      assert !root_section.destroy
-      assert_equal section_count, Cms::Section.count
-    end
-
-    def test_empty_section
-      @section = Factory(:section, :parent => @root)
-
-      assert @section.empty?
-      assert @section.deletable?
-
-      section_count = Cms::Section.count
-      section_node_count = Cms::SectionNode.count
-      assert @section.destroy
-      assert_decremented section_count, Cms::Section.count
-      assert_decremented section_node_count, Cms::SectionNode.count
-    end
-
-    def test_creating_page_with_reserved_path
-      @section = Cms::Section.new(:name => "FAIL", :path => "/cms")
-      assert_not_valid @section
-      assert_has_error_on(@section, :path, "is invalid, '/cms' a reserved path")
-
-      @section = Cms::Section.new(:name => "FAIL", :path => "/cache")
-      assert_not_valid @section
-      assert_has_error_on(@section, :path, "is invalid, '/cache' a reserved path")
-
-      @section = Cms::Section.new(:name => "FTW", :path => "/whatever")
-      assert_valid @section
-    end
-
-    def test_old_syntax_for_marking_group_sections
-      given_there_is_a_group = Factory(:group)
-
-      groups = Cms::Group.all(&:id)
-      assert_equal Cms::Group, groups[0].class, "This is previous"
-
-      groups = Cms::Group.all()
-      assert_equal Cms::Group, groups[0].class, "No difference between this and the previous call."
-
-      group_ids = Cms::Group.all.map(&:id)
-      assert_equal Fixnum, group_ids[0].class
-    end
-
-    def test_new_section_with_groups
-      section = Cms::Section.new(:allow_groups => :all)
-      assert_equal Cms::Group.all, section.groups
-
-    end
-
-    def test_new_section_with_no_groups
-      s = Cms::Section.new(:allow_groups => :none)
-      assert_equal 0, s.groups.size
-    end
-
-    def test_create_section
-      s = Cms::Section.create!(:name => "For All", :path => "/", :allow_groups => :all)
-
-      assert_equal Cms::Group.count, Cms::Section.with_path("/").first.groups.size
-    end
-  end
-
-  class TestsWithoutFixtures < ActiveSupport::TestCase
-    def setup
-      remove_all_sitemap_fixtures_to_avoid_bugs
-    end
-
-    def test_find_by_name_path
-      @a = Factory(:section, :parent => root_section, :name => "A")
-      @b = Factory(:section, :parent => @a, :name => "B")
-      @c = Factory(:section, :parent => @b, :name => "C")
-
-      assert_equal root_section, Section.find_by_name_path("/")
-      assert_equal @a, Section.find_by_name_path("/A/")
-      assert_equal @b, Section.find_by_name_path("/A/B/")
-      assert_equal @c, Section.find_by_name_path("/A/B/C/")
-    end
-  end
-
-  class TestAncestors < ActiveSupport::TestCase
-
-    def setup
-      given_there_is_a_guest_group
-      @visible_section = Factory(:public_section, :parent => root_section)
-      @hidden_section = Factory(:public_section, :parent => root_section, :hidden => true)
-      @visible_page = Factory(:public_page, :section => root_section)
-      @hidden_page = Factory(:public_page, :hidden => true, :section => root_section)
-      @file_block = Factory(:file_block, :attachment_section => root_section, :attachment_file => mock_file)
-    end
-
-    test "visible_child_nodes should include non-hidden sections and non-hidden pages" do
-      assert_equal [@visible_section.node, @visible_page.node], root_section.visible_child_nodes
-    end
-
-    test "ancestors :include_self" do
-      assert_equal [root_section], @visible_section.ancestors
-      assert_equal [root_section, @visible_section], @visible_section.ancestors(:include_self => true)
-    end
-
-    test "#ancestry_path delegates to SectionNode" do
-      assert_equal @visible_section.node.ancestry_path, @visible_section.ancestry_path
-    end
-
-    test "#build_section creates a new section within this section" do
-      new_section = @visible_section.build_section
-      assert_equal @visible_section, new_section.parent
-    end
-
-    test "#partial_for" do
-      assert_equal "section", @visible_section.partial_for
-      assert_equal "page", @visible_page.partial_for
-      assert_equal "link", Factory(:link, :section => root_section).partial_for
-    end
-
-    test "#status is cached" do
-      assert_equal :unlocked, @visible_section.status
-      assert_equal :unlocked, @visible_section.instance_variable_get(:@status)
-    end
-
-    test "Section#section_node should be the same object " do
-      sn = root_section.section_node
-      assert_equal sn.object_id, sn.node.section_node.object_id, "Should be the same object"
-    end
-
-    test "Page#section_node should be the same object" do
-      sn = @visible_page.section_node
-      assert_equal sn.object_id, sn.node.section_node.object_id
-    end
-
-    test "Link#section_node should be the same object" do
-      link = Factory(:link, :section => root_section)
-      sn = link.section_node
-      assert_equal sn.object_id, sn.node.section_node.object_id
-    end
-
-    test "#public?" do
-      assert @visible_section.public?
-      refute Factory(:section).public?
-    end
-
-    test "#sitemap" do
-      sitemap = Section.sitemap
-      assert_equal root_section.node, sitemap.keys.first
-      assert_equal [@visible_section, @hidden_section, @visible_page, @hidden_page].map { |n| n.section_node }, sitemap[root_section.node].keys
-    end
-
-    test "#master_section_list" do
-      subsection = Factory(:public_section, :parent => @visible_section, :name => "Child 1")
-      sections = root_section.master_section_list
-      assert_equal [@visible_section, subsection, @hidden_section], sections
-      assert_equal "#{@visible_section.name}", sections[0].full_path
-      assert_equal "#{@visible_section.name} / #{subsection.name}", sections[1].full_path
-      assert_equal "#{@hidden_section.name}", sections[2].full_path
-    end
-
-  end
-end

data/test/unit/models/site_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-class SiteTest < ActiveSupport::TestCase
-
-  def test_does_not_allow_duplicate_names
-    Factory(:site, :domain => "test.com")
-    @site = Factory.build(:site, :domain => "test.com")
-    assert !@site.valid?
-    assert_has_error_on @site, :domain, "has already been taken"
-  end
-
-  def test_remove_www_from_front_when_saving
-    @site = Factory(:site, :domain => "www.test.com")
-    assert_equal "test.com", @site.domain
-  end
-  
-  def test_should_remove_www_from_front_when_saving_preserving_sub_domains
-    @site = Factory(:site, :domain => "www.foo.test.com")
-    assert_equal "foo.test.com", @site.domain
-  end
-  
-  def test_should_not_remove_sub_domain_from_domain_when_saving
-    @site = Factory(:site, :domain => "foo.test.com")
-    assert_equal "foo.test.com", @site.domain
-  end
-  
-  def test_should_make_the_first_the_default
-    @first = Factory(:site)
-    @second = Factory(:site)
-    assert @first.the_default?
-    assert !@second.the_default?
-  end
-  
-  def test_change_the_default
-    @first = Factory(:site, :the_default=>false)
-    @second = Factory(:site, :the_default => true)
-    reset(:first, :second)
-    assert !@first.the_default?
-    assert @second.the_default?
-  end
-  
-  def test_find_by_domain
-    @default =     @first = Factory(:site, :the_default=>true)
-    @example = Factory(:site, :domain => "test.com")
-    assert_equal @example, Cms::Site.find_by_domain("test.com")
-    assert_equal @example, Cms::Site.find_by_domain("www.test.com")
-    assert_equal @default, Cms::Site.find_by_domain("whatever.com")
-  end
-  
-end

data/test/unit/models/task_test.rb

@@ -1,150 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class TaskTest < ActiveSupport::TestCase
-    def setup
-      super
-      @editor_a = Factory(:cms_admin)
-      @editor_b = Factory(:cms_admin)
-      @non_editor = Factory(:user, :login => "non_editor", :email => "non_editor@example.com")
-      @page = Factory(:page, :name => "Task Test", :path => "/task_test")
-      @page2 = Factory(:page, :name => "Task Test 2", :path => "/task_test_2")
-    end
-  end
-
-  class CreateTaskTest < TaskTest
-
-    def test_create_task
-      assert_that_you_can_assign_a_task_to_yourself
-      assert_that_an_assigned_by_user_that_is_an_editor_is_required
-      assert_that_an_assigned_to_user_that_is_an_editor_is_required
-      assert_that_a_page_is_required
-
-      create_the_task!
-      create_the_second_task!
-
-      assert !@task.completed?
-      assert(@task.due_date < Time.now)
-      assert_equal "Howdy!", @task.comment
-
-      assert_that_an_email_is_sent_to_the_user_the_task_was_assigned_to
-      assert_that_the_page_is_assigned_to_the_assigned_to_user
-      assert_that_the_task_is_added_to_the_users_incomplete_tasks
-    end
-
-    test "An email is sent when a task is created" do
-      create_the_task!
-
-      assert_equal 1, ActionMailer::Base.deliveries.size
-    end
-
-    protected
-
-    def assert_that_you_can_assign_a_task_to_yourself
-      assert_valid Factory.build(:task, :assigned_by => @editor_a, :assigned_to => @editor_a)
-    end
-
-    def assert_that_an_assigned_by_user_that_is_an_editor_is_required
-      task = Factory.build(:task, :assigned_by => nil, :assigned_to => @editor_a)
-      assert_not_valid task
-      assert_has_error_on task, :assigned_by_id, "is required"
-
-      task = Factory.build(:task, :assigned_by => @non_editor, :assigned_to => @editor_a)
-      assert_not_valid task
-      assert_has_error_on task, :assigned_by_id, Cms::Task::CANT_ASSIGN_MESSAGE
-    end
-
-    def assert_that_an_assigned_to_user_that_is_an_editor_is_required
-      task = Factory.build(:task, :assigned_by => @editor_a, :assigned_to => nil)
-      assert_not_valid task
-      assert_has_error_on task, :assigned_to_id, "is required"
-
-      task = Factory.build(:task, :assigned_by => @editor_a, :assigned_to => @non_editor)
-      assert_not_valid task
-      assert_has_error_on task, :assigned_to_id, Cms::Task::CANT_BE_ASSIGNED_MESSAGE
-    end
-
-    def assert_that_a_page_is_required
-      task = Factory.build(:task, :page => nil)
-      assert_not_valid task
-      assert_has_error_on task, :page_id, "is required"
-    end
-
-    def create_the_task!
-      @task = Cms::Task.create!(
-          :assigned_by => @editor_a,
-          :assigned_to => @editor_b,
-          :due_date => 5.minutes.ago,
-          :comment => "Howdy!",
-          :page => @page)
-    end
-
-    def create_the_second_task!
-      @task2 = Cms::Task.create!(
-          :assigned_by => @editor_a,
-          :assigned_to => @editor_b,
-          :due_date => 1.minutes.ago,
-          :comment => "Howdy Again!",
-          :page => @page2)
-    end
-
-    def assert_that_an_email_is_sent_to_the_user_the_task_was_assigned_to
-      email = Cms::EmailMessage.first(:order => "id asc")
-      assert_equal @editor_a.email, email.sender
-      assert_equal @editor_b.email, email.recipients
-      assert_equal "Page '#{@page.name}' has been assigned to you", email.subject
-      assert_equal "http://cms.#{SITE_DOMAIN}#{@page.path}\n\n#{@task.comment}", email.body
-    end
-
-    def assert_that_the_page_is_assigned_to_the_assigned_to_user
-      assert @page.assigned_to?(@editor_b), "Expected the page to be assigned to editor b"
-      assert !@page.assigned_to?(@editor_a), "Expected the page not to be assigned to editor a"
-    end
-
-    def assert_that_the_task_is_added_to_the_users_incomplete_tasks
-      assert !@editor_a.tasks.incomplete.all.include?(@task),
-             "Expected Editor A's incomplete tasks not to include the task"
-      assert !@editor_a.tasks.incomplete.all.include?(@task2),
-             "Expected Editor A's incomplete tasks not to include the second task"
-      assert @editor_b.tasks.incomplete.all.include?(@task),
-             "Expected Editor B's incomplete tasks to include the task"
-      assert @editor_b.tasks.incomplete.all.include?(@task2),
-             "Expected Editor B's incomplete tasks to include the second task"
-    end
-
-  end
-
-  class ExistingIncompleteTaskTest < TaskTest
-    def setup
-      super
-      @existing_task = Factory(:task, :assigned_by => @editor_a, :assigned_to => @editor_b, :page => @page)
-    end
-
-
-    test "Existing task is incomplete, and assigned to Editor B's task list" do
-      assert !@existing_task.completed?
-      assert_equal @editor_b, @page.assigned_to
-      assert @editor_b.tasks.incomplete.all.include?(@existing_task)
-    end
-
-    def test_create_task_for_a_page_with_existing_incomplete_tasks
-      @new_task = Factory(:task, :assigned_by => @editor_b, :assigned_to => @editor_a, :page => @page)
-      @existing_task = Cms::Task.find(@existing_task.id)
-
-      assert @existing_task.completed?
-      assert !@new_task.completed?
-      assert @page.assigned_to?(@editor_a)
-      assert !@page.assigned_to?(@editor_b)
-      assert @editor_a.tasks.incomplete.all.include?(@new_task)
-      assert !@editor_b.tasks.incomplete.all.include?(@existing_task)
-    end
-
-    test "Marking a task complete should mark it as unassigned" do
-      @existing_task.mark_as_complete!
-
-      assert @existing_task.completed?
-      assert @page.assigned_to.nil?
-      assert !@editor_b.tasks.incomplete.all.include?(@existing_task)
-    end
-  end
-end