we5-browsercms 3.0.5.1 → 3.1.0

data/test/unit/models/sections_test.rb

@@ -51,6 +51,18 @@ class SectionTest < ActiveSupport::TestCase
     
     assert_equal @a2, @a.first_page_or_link
   end
+
+  def test_find_first_page_or_link_after_delete
+    @a = Factory(:section, :parent => root_section, :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")
@@ -121,5 +133,32 @@ class SectionTest < ActiveSupport::TestCase
     @section = Section.new(:name => "FTW", :path => "/whatever")
     assert_valid @section
   end  
-  
-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

data/test/unit/models/task_test.rb

@@ -3,13 +3,14 @@ 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_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")          
+    @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
@@ -17,13 +18,14 @@ class CreateTaskTest < TaskTest
     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
@@ -44,38 +46,47 @@ class CreateTaskTest < TaskTest
       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"    
+      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"      
+      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"      
+      assert_has_error_on task, :page_id, "is required"
     end
 
     def create_the_task!
       @task = Task.create!(
-        :assigned_by => @editor_a, 
+        :assigned_by => @editor_a,
         :assigned_to => @editor_b,
         :due_date => 5.minutes.ago,
         :comment => "Howdy!",
-        :page => @page)      
+        :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 => "created_at desc")
+      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://#{SITE_DOMAIN}#{@page.path}\n\n#{@task.comment}", email.body      
+      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
@@ -84,12 +95,16 @@ class CreateTaskTest < TaskTest
     end
 
     def assert_that_the_task_is_added_to_the_users_incomplete_tasks
-      assert !@editor_a.tasks.incomplete.all.include?(@task), 
+      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"      
+        "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
@@ -100,7 +115,7 @@ class ExistingIncompleteTaskTest < TaskTest
 
   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)
 
@@ -115,12 +130,12 @@ class ExistingIncompleteTaskTest < TaskTest
   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)    
+    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)    
+    assert !@editor_b.tasks.incomplete.all.include?(@existing_task)
   end
 end

data/test/unit/models/user_test.rb

@@ -1,21 +1,22 @@
 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
@@ -30,30 +31,54 @@ class UserTest < ActiveSupport::TestCase
 
     @user.expires_at = 1.day.ago
     assert @user.expired?
-  end  
+  end
+
+  def test_active
+    @user = Factory(:user)
+    assert User.active.all.include?(@user)
+
+    @user.update_attribute(:expires_at, 1.year.from_now)
+    assert User.active.all.include?(@user)
+  end
+
+  test "Disable should work regardless of time zone" do
+    @user = Factory(:user)
+
+    Time.zone = "UTC"
+    @user.disable!
+    assert !User.active.all.include?(@user)
+
+    user2 = Factory(:user)
+    Time.zone = "Eastern Time (US & Canada)"
+    user2.disable!
+    assert !User.active.all.include?(user2)
+
+  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.disable!
+
+    assert @user.expires_at <= Time.now.utc
     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 
+
+  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
@@ -66,6 +91,63 @@ class UserTest < ActiveSupport::TestCase
       assert !@user.valid?
     end
   end
+  test "full name or login" do
+    login = 'robbo'
+    fn = 'Bob'
+    ln = 'Smith'
+    u = User.new(:login => 'robbo')
+    assert_equal login, u.full_name_or_login
+    u.first_name = fn
+    assert_equal fn, u.full_name_or_login
+    u.last_name = ln
+    assert_equal fn + ' ' + ln, u.full_name_or_login
+
+  end
+end
+
+class UserAbleToViewTest < ActiveSupport::TestCase
+
+  test "User able_to_view? with String path" do
+    non_admin = GroupType.create!(:cms_access=>false)
+    group = Factory(:group, :group_type=>non_admin)
+    public_user = Factory(:user)
+    public_user.groups<< group
+    public_user.save!
+
+    section = Factory(:section, :path=>"/members", :name=>"Members")
+    section.groups << group
+    section.save!
+
+    assert public_user.able_to_view?("/members")
+  end
+
+  test "User can't view a nil section" do
+    user = User.new
+
+    Section.expects(:find_by_path).with("/members").returns(nil)
+    user.expects(:able_to_view_without_paths?).never
+
+    assert_raise ActiveRecord::RecordNotFound do
+      user.able_to_view?("/members")
+    end
+
+  end
+
+  test "Users with cmsaccess?" do
+    @non_admin = GroupType.create!(:cms_access=>true)
+    @group = Factory(:group, :group_type=>@non_admin)
+    @public_user = Factory(:user)
+    @public_user.groups<< @group
+    @public_user.save!
+
+    assert(@public_user.cms_access?, "")
+  end
+
+  test "cms_access? determines if a user is considered to have cmsadmin privledges or not." do
+    user = User.new
+    assert(!user.cms_access?, "")
+  end
+
 
 end
 
@@ -74,137 +156,137 @@ class UserPermissionsTest < ActiveSupport::TestCase
     @user = Factory(:user)
     @guest_group = Group.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_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])
+            :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])
+            :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])
-    
+            :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
@@ -215,7 +297,7 @@ class GuestUserTest < ActiveSupport::TestCase
     @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
@@ -223,6 +305,38 @@ class GuestUserTest < ActiveSupport::TestCase
     assert !@user.able_to?("do anything global")
     assert @user.able_to_view?(@public_page)
     assert !@user.able_to_view?(@protected_page)
+    assert !@user.cms_access?
+  end
+
+  test "override viewable sections for the guest group" do
+    @user.expects(:viewable_sections).returns([@protected_section])
+    assert_equal Section, @protected_section.class
+    assert(@protected_section.is_a?(Section), "")
+    assert @user.able_to_view?(@protected_section)
   end
-  
+
+  test "GuestUser can't view a nil section" do
+    user = GuestUser.new
+
+    Section.expects(:find_by_path).with("/members").returns(nil)
+
+    assert_raise ActiveRecord::RecordNotFound do
+      user.able_to_view?("/members")
+    end
+
+  end
+
+  test "Guest User able_to_view? with String path" do
+    section = Factory(:section, :path=>"/members", :name=>"Members")
+    section.groups << @guest_group
+    section.save!
+
+    assert @user.able_to_view?("/members")
+
+  end
+
+  test "Group.guest is in fixtures." do
+    assert_not_nil Group.guest, "Expected to be in the database for tests."
+  end
+
 end