browsercms_s3 3.0.3

data/test/unit/models/permission_test.rb

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

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+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
+end

data/test/unit/models/section_node_test.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class SectionNodeTest < ActiveSupport::TestCase
+  def setup
+    @parent = Factory(:section, :parent => root_section, :name => "Parent")
+    @a = Factory(:section, :parent => @parent, :name => "A")
+    @a1 = Factory(:page, :section => @a, :name => "A1")
+    @a2 = Factory(:page, :section => @a, :name => "A2")
+    @a3 = Factory(:page, :section => @a, :name => "A3")
+    @b = Factory(:section, :parent => @parent, :name => "B")
+    @b1 = Factory(:page, :section => @b, :name => "B1")
+    @b2 = Factory(:page, :section => @b, :name => "B2")
+    @b3 = Factory(:page, :section => @b, :name => "B3")    
+    
+    @node_a = @a.node
+    @node_b = @b.node
+    @node_a1 = @a1.section_node
+    @node_a2 = @a2.section_node
+    @node_a3 = @a3.section_node
+    @node_b1 = @b1.section_node
+    @node_b2 = @b2.section_node
+    @node_b3 = @b3.section_node
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)    
+  end
+  def test_reorder_nodes_within_same_section
+    @node_a2.move_to(@a, 1)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    log_table_without_stamps(SectionNode)
+    assert_properties(@node_a, :section_id => @parent.id, :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :section_id => @parent.id, :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :section_id => @a.id, :node_type => "Page", :node_id => @a1.id, :position => 2)
+    assert_properties(@node_a2, :section_id => @a.id, :node_type => "Page", :node_id => @a2.id, :position => 1)
+    assert_properties(@node_a3, :section_id => @a.id, :node_type => "Page", :node_id => @a3.id, :position => 3)
+    assert_properties(@node_b1, :section_id => @b.id, :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :section_id => @b.id, :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :section_id => @b.id, :node_type => "Page", :node_id => @b3.id, :position => 3)    
+  end
+  def test_move_nodes_to_different_section
+    @node_a2.move_to(@b, 2)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :section_id => @parent.id, :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :section_id => @parent.id, :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :section_id => @a.id, :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :section_id => @b.id, :node_type => "Page", :node_id => @a2.id, :position => 2)
+    assert_properties(@node_a3, :section_id => @a.id, :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :section_id => @b.id, :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :section_id => @b.id, :node_type => "Page", :node_id => @b2.id, :position => 3)
+    assert_properties(@node_b3, :section_id => @b.id, :node_type => "Page", :node_id => @b3.id, :position => 4)
+  end
+  def test_move_nodes_to_beginning_of_different_section
+    @node_a2.move_to(@b, 1)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :section_id => @parent.id, :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :section_id => @parent.id, :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :section_id => @a.id, :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :section_id => @b.id, :node_type => "Page", :node_id => @a2.id, :position => 1)
+    assert_properties(@node_a3, :section_id => @a.id, :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :section_id => @b.id, :node_type => "Page", :node_id => @b1.id, :position => 2)
+    assert_properties(@node_b2, :section_id => @b.id, :node_type => "Page", :node_id => @b2.id, :position => 3)
+    assert_properties(@node_b3, :section_id => @b.id, :node_type => "Page", :node_id => @b3.id, :position => 4)
+  end
+  def test_move_nodes_to_end_of_different_section
+    @node_a2.move_to(@b, 99)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :section_id => @parent.id, :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :section_id => @parent.id, :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :section_id => @a.id, :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :section_id => @b.id, :node_type => "Page", :node_id => @a2.id, :position => 4)
+    assert_properties(@node_a3, :section_id => @a.id, :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :section_id => @b.id, :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :section_id => @b.id, :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :section_id => @b.id, :node_type => "Page", :node_id => @b3.id, :position => 3)
+  end
+  def test_put_page_at_the_bottom_when_section_is_changed
+    @a2.update_attributes(:section_id => @b.id)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :section_id => @parent.id, :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :section_id => @parent.id, :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :section_id => @a.id, :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :section_id => @b.id, :node_type => "Page", :node_id => @a2.id, :position => 4)
+    assert_properties(@node_a3, :section_id => @a.id, :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :section_id => @b.id, :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :section_id => @b.id, :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :section_id => @b.id, :node_type => "Page", :node_id => @b3.id, :position => 3)
+  end
+  def test_find_ancestors
+    assert root_section.ancestors.empty?
+    assert_equal [root_section], @parent.ancestors
+    assert_equal [root_section, @parent], @a.ancestors
+    assert_equal [root_section, @parent, @a], @a1.ancestors
+  end
+end

data/test/unit/models/sections_test.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class SectionTest < ActiveSupport::TestCase
+  
+  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
+  
+  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_section)
+    bar = Factory(:section, :name => "Bar", :parent => root_section)
+    assert_equal root_section, 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_section)
+    assert !root_section.move_to(foo)
+  end
+  
+  def test_find_first_page_or_link_in_section_page
+    @a = Factory(:section, :parent => root_section, :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_section, :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_section, :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_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  
+  
+  def test_section_with_sub_section
+    @section = Factory(:section, :parent => root_section)
+    Factory(:section, :parent => @section)
+
+    assert !@section.empty?
+    assert !@section.deletable?
+
+    section_count = Section.count
+    assert !@section.destroy
+    assert_equal section_count, Section.count
+  end
+  
+  def test_section_with_page
+    @section = Factory(:section, :parent => root_section)
+    Factory(:page, :section => @section)
+
+    assert !@section.empty?
+    assert !@section.deletable?
+    
+    section_count = Section.count
+    assert !@section.destroy
+    assert_equal section_count, Section.count
+  end
+  
+  def test_root_section
+    @section = root_section
+
+    assert !@section.empty?
+    assert !@section.deletable?
+    
+    section_count = Section.count
+    assert !@section.destroy
+    assert_equal section_count, Section.count
+  end  
+  
+  def test_empty_section
+    @section = Factory(:section, :parent => root_section)
+    
+    assert @section.empty?
+    assert @section.deletable?
+    
+    section_count = Section.count
+    assert @section.destroy
+    assert_decremented section_count, Section.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  
+  
+end

data/test/unit/models/site_test.rb

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

@@ -0,0 +1,126 @@
+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")          
+  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!
+  
+    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 assert_that_an_email_is_sent_to_the_user_the_task_was_assigned_to
+      email = EmailMessage.first(:order => "created_at desc")
+      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://#{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_b.tasks.incomplete.all.include?(@task),
+        "Expected Editor B's incomplete tasks to include the 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

data/test/unit/models/user_test.rb

@@ -0,0 +1,228 @@
+require File.join(File.dirname(__FILE__), '/../../test_helper')
+
+class UserTest < ActiveSupport::TestCase
+  
+  should_validate_presence_of :login, :password, :password_confirmation
+  should_validate_uniqueness_of :login
+  
+  def test_authenticate
+    @user = Factory(:user)
+    assert_equal @user, User.authenticate(@user.login, @user.password)
+    assert_nil User.authenticate(@user.login, 'FAIL')
+  end
+  
+  def test_authenticate_expired_user
+    @user = Factory(:user)
+    @user.disable!
+    assert_nil User.authenticate(@user.login, @user.password)
+  end
+  def test_expiration
+    @user = Factory.build(:user)
+    assert_nil @user.expires_at
+    assert_nil @user.expires_at_formatted
+    assert !@user.expired?
+
+    @user.expires_at = 1.day.from_now
+    assert !@user.expired?
+
+    @user.expires_at = Time.now
+    assert @user.expired?
+
+    @user.expires_at = 1.day.ago
+    assert @user.expired?
+  end  
+  def test_disable_enable
+    @user = Factory(:user)
+
+    assert_nil @user.expires_at
+    assert !@user.expired?
+    assert User.active.all.include?(@user)
+    
+    @user.disable!
+
+    assert @user.expires_at <= Time.now
+    assert @user.expired?
+    assert !User.active.all.include?(@user)
+
+    @user.enable!
+    
+    assert_nil @user.expires_at
+    assert !@user.expired?
+    assert User.active.all.include?(@user)
+  end
+  test "email validation" do 
+    @user = Factory(:user)
+    assert @user.valid?
+    
+    valid_emails = ['t@test.com', 'T@test.com', 'test@somewhere.mobi', 'test@somewhere.tv', 'joe_blow@somewhere.co.nz', 'joe_blow@somewhere.com.au', 't@t-t.co']
+    valid_emails.each do |email|
+      @user.email = email
+      assert @user.valid?
+    end
+
+    invalid_emails = ['', '@test.com', '@test', 'test@test', 'test@somewhere', 'test@somewhere.', 'test@somewhere.x', 'test@somewhere..']
+    invalid_emails.each do |email|
+      @user.email = email
+      assert !@user.valid?
+    end
+  end
+
+end
+
+class UserPermissionsTest < ActiveSupport::TestCase
+  def setup
+    @user = Factory(:user)
+    @guest_group = Group.first(:conditions => {:code => "guest"})    
+  end
+  
+  def test_user_permissions
+    @have = Factory(:permission, :name => "do something the group has permission to do")
+    @havenot = Factory(:permission, :name => "do something the group does not have permission to do")
+    @group_a = Factory(:group)
+    @group_b = Factory(:group) 
+
+    @group_a.permissions << @have
+    @group_b.permissions << @havenot
+
+    @user.groups << @group_a
+    
+    assert @user.able_to?("do something the group has permission to do")
+    assert !@user.able_to?("do something the group does not have permission to do")
+  end
+  
+  test "cms user access to nodes" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "CMS User", :cms_access => true))
+    @user.groups << @group
+    
+    @modifiable_section = Factory(:section, :parent => root_section, :name => "Modifiable")
+    @non_modifiable_section = Factory(:section, :parent => root_section, :name => "Not Modifiable")
+    
+    @group.sections << @modifiable_section
+    
+    @modifiable_page = Factory(:page, :section => @modifiable_section)
+    @non_modifiable_page = Factory(:page, :section => @non_modifiable_section)
+    
+    @modifiable_link = Factory(:link, :section => @modifiable_section)
+    @non_modifiable_link = Factory(:link, :section => @non_modifiable_section)
+    
+    assert @user.able_to_modify?(@modifiable_section)
+    assert !@user.able_to_modify?(@non_modifiable_section)
+    
+    assert @user.able_to_modify?(@modifiable_page)
+    assert !@user.able_to_modify?(@non_modifiable_page)
+    
+    assert @user.able_to_modify?(@modifiable_link)
+    assert !@user.able_to_modify?(@non_modifiable_link)
+  end
+  
+  test "cms user access to connectables" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "CMS User", :cms_access => true))
+    @user.groups << @group
+    
+    @modifiable_section = Factory(:section, :parent => root_section, :name => "Modifiable")
+    @non_modifiable_section = Factory(:section, :parent => root_section, :name => "Not Modifiable")
+    
+    @group.sections << @modifiable_section
+    
+    @modifiable_page = Factory(:page, :section => @modifiable_section)
+    @non_modifiable_page = Factory(:page, :section => @non_modifiable_section)
+    
+    @all_modifiable_connectable = stub(
+      :class => stub(:content_block? => true, :connectable? => true),
+      :connected_pages => [@modifiable_page])
+    @some_modifiable_connectable = stub(
+      :class => stub(:content_block? => true, :connectable? => true),
+      :connected_pages => [@modifiable_page, @non_modifiable_page])
+    @none_modifiable_connectable = stub(
+      :class => stub(:content_block? => true, :connectable? => true),
+      :connected_pages => [@non_modifiable_page])
+    
+    assert @user.able_to_modify?(@all_modifiable_connectable)
+    assert !@user.able_to_modify?(@some_modifiable_connectable)
+    assert !@user.able_to_modify?(@none_modifiable_connectable)
+  end
+  
+  test "cms user access to non-connectable content blocks" do
+    @content_block = stub(:class => stub(:content_block? => true))
+    assert @user.able_to_modify?(@content_block)
+  end
+  
+  test "non cms user access to nodes" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "Registered User"))
+    @user.groups << @group
+    
+    @modifiable_section = Factory(:section, :parent => root_section, :name => "Modifiable")
+    @group.sections << @modifiable_section
+    @non_modifiable_section = Factory(:section, :parent => root_section, :name => "Not Modifiable")
+    
+    @modifiable_page = Factory(:page, :section => @modifiable_section)
+    @non_modifiable_page = Factory(:page, :section => @non_modifiable_section)
+
+    assert !@user.able_to_modify?(@modifiable_section)
+    assert !@user.able_to_modify?(@non_modifiable_section)
+    
+    assert @user.able_to_view?(@modifiable_page)
+    assert !@user.able_to_view?(@non_modifiable_page)
+  end
+  
+  test "cms user with no permissions should still be able to view pages" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "CMS User", :cms_access => true))
+    @user.groups << @group
+    
+    @page = Factory(:page)
+    assert @user.able_to_view?(@page)
+  end
+  
+  test "cms user who can edit content" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "CMS User", :cms_access => true))
+    @group.permissions << create_or_find_permission_named("edit_content")
+    @user.groups << @group
+    
+    node = stub
+    
+    @user.stubs(:able_to_modify?).with(node).returns(true)
+    assert @user.able_to_edit?(node)
+    assert !@user.able_to_publish?(node)
+    
+    @user.stubs(:able_to_modify?).with(node).returns(false)
+    assert !@user.able_to_edit?(node)
+    assert !@user.able_to_publish?(node)
+  end
+  
+  test "cms user who can publish content" do
+    @group = Factory(:group, :name => "Test", :group_type => Factory(:group_type, :name => "CMS User", :cms_access => true))
+    @group.permissions << create_or_find_permission_named("publish_content")
+    @user.groups << @group
+    
+    node = stub
+    
+    @user.stubs(:able_to_modify?).with(node).returns(true)
+    assert !@user.able_to_edit?(node)
+    assert @user.able_to_publish?(node)
+    
+    @user.stubs(:able_to_modify?).with(node).returns(false)
+    assert !@user.able_to_edit?(node)
+    assert !@user.able_to_publish?(node)
+  end
+  
+end
+
+class GuestUserTest < ActiveSupport::TestCase
+  def setup
+    @user = User.guest
+    @guest_group = Group.with_code("guest").first
+    @public_page = Factory(:page, :section => root_section)
+    @protected_section = Factory(:section, :parent => root_section)
+    @protected_page = Factory(:page, :section => @protected_section)
+  end
+  
+  def test_guest
+    assert @user.guest?
+    assert_equal @guest_group, @user.group
+    assert @user.groups.include?(@guest_group)
+    assert !@user.able_to?("do anything global")
+    assert @user.able_to_view?(@public_page)
+    assert !@user.able_to_view?(@protected_page)
+  end
+  
+end