browsercms 3.1.5 → 3.3.0.beta

data/test/unit/models/permission_test.rb

@@ -1,10 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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, Permission.named("test").first
-  end
-end

data/test/unit/models/portlet_test.rb

@@ -1,69 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-# For some reason, these Portlet classes cannot be defined within the PortletTest class. Something
-# related to the dynamic attributes causes other tests to fail.
-class NoInlinePortlet < Portlet
-  render_inline false
-end
-class InlinePortlet < Portlet
-end
-
-class NonEditablePortlet < Portlet
-  enable_template_editor false
-end
-
-class EditablePortlet < Portlet
-  enable_template_editor true
-end
-
-
-class PortletTest < ActiveSupport::TestCase
-
-  def test_dynamic_attributes
-    portlet = DynamicPortlet.create(:name => "Test", :foo => "FOO")
-    assert_equal "FOO", 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 = Portlet.types
-    assert list.size > 0
-
-    DynamicPortlet.create!(:name=>"test 1")
-    DynamicPortlet.create!(:name=>"test 2")
-
-    assert_equal list.size, 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
-end

data/test/unit/models/sections_test.rb

@@ -1,264 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-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)
-    assert_equal sub, @root.sections.last
-    assert_equal @root, 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_section_with_child_sections_should_not_be_deletable
-    @section = Factory(:section, :parent => @root)
-    Factory(:section, :parent => @section)
-
-    assert !@section.empty?
-    assert !@section.deletable?
-
-    assert_no_difference 'Section.count; SectionNode.count' do
-      @section.destroy
-    end
-  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 = Section.count
-    assert !@section.destroy
-    assert_equal section_count, Section.count
-  end
-  
-  def test_a_root_section_shouldnt_be_deletable_even_without_children
-    root = Factory(:root_section)
-
-    assert root.empty?
-    assert !root.deletable?
-
-    assert_no_difference 'Section.count' do
-      assert !root.destroy
-    end
-  end  
-  
-  def test_empty_section
-    @section = Factory(:section, :parent => @root)
-    
-    assert @section.empty?
-    assert @section.deletable?
-
-    section_count = Section.count
-    section_node_count = SectionNode.count
-    assert @section.destroy
-    assert_decremented section_count, Section.count
-    assert_decremented section_node_count, SectionNode.count
-  end
-  
-  def test_creating_page_with_reserved_path
-    @section = Section.new(:name => "FAIL", :path => "/cms")
-    assert_not_valid @section
-    assert_has_error_on(@section, :path, "is invalid, '/cms' a reserved path")
-    
-    @section = Section.new(:name => "FAIL", :path => "/cache")
-    assert_not_valid @section
-    assert_has_error_on(@section, :path, "is invalid, '/cache' a reserved path")
-    
-    @section = Section.new(:name => "FTW", :path => "/whatever")
-    assert_valid @section
-  end  
-
-  def test_old_syntax_for_marking_group_sections
-    groups = Group.all(&:id)
-    assert_equal Group, groups[0].class, "This is previous"
-
-    groups = Group.all()
-    assert_equal Group, groups[0].class, "No difference between this and the previous call."
-
-    group_ids = Group.all.map(&:id)
-    assert_equal Fixnum, group_ids[0].class
-  end
-
-  def test_new_section_with_groups
-    section = Section.new(:allow_groups=>:all)
-    assert_equal Group.all, section.groups
-
-  end
-
-  def test_new_section_with_no_groups
-    s = Section.new(:allow_groups=>:none)
-    assert_equal 0, s.groups.size
-  end
-
-  def test_create_section
-    s = Section.create!(:name=>"For All", :path=>"/", :allow_groups=>:all)
-
-    assert_equal Group.count, 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
-    remove_all_sitemap_fixtures_to_avoid_bugs
-    @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

data/test/unit/models/site_test.rb

@@ -1,50 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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 = Site.default.first
-    @second = Factory(:site)
-    assert @first.the_default?
-    assert !@second.the_default?
-  end
-  
-  def test_change_the_default
-    @first = Factory(:site)
-    @second = Factory(:site, :the_default => true)
-    reset(:first, :second)
-    assert !@first.the_default?
-    assert @second.the_default?
-  end
-  
-  def test_find_by_domain
-    @default = Site.default.first
-    @example = Factory(:site, :domain => "test.com")
-    assert_equal @example, Site.find_by_domain("test.com")
-    assert_equal @example, Site.find_by_domain("www.test.com")
-    assert_equal @default, Site.find_by_domain("whatever.com")
-  end
-  
-end

data/test/unit/models/task_test.rb

@@ -1,141 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-class TaskTest < ActiveSupport::TestCase
-  def setup
-    super
-    @editor_a = create_admin_user(:login => "editor_a", :email => "editor_a@example.com")
-    @editor_b = create_admin_user(:login => "editor_b", :email => "editor_b@example.com")
-    @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
-
-  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, "cannot assign tasks"
-    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, "cannot be assigned tasks"
-    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 = 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 = 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 = 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
-
-  def test_create_task_for_a_page_with_existing_incomplete_tasks
-    assert !@existing_task.completed?
-
-    @new_task = Factory(:task, :assigned_by => @editor_b, :assigned_to => @editor_a, :page => @page)
-    @existing_task = 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
-
-  def test_completing_a_task
-    assert !@existing_task.completed?
-    assert_equal @editor_b, @page.assigned_to
-    assert @editor_b.tasks.incomplete.all.include?(@existing_task)
-
-    @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