browsercms 3.3.4 → 3.4.0.rc1

data/test/unit/models/user_test.rb

@@ -0,0 +1,358 @@
+require 'test_helper'
+
+module Cms
+  class UserTest < ActiveSupport::TestCase
+
+    def setup
+      @need_at_least_one_enabled_user = Factory(:user)
+      @user = Factory(:user)
+    end
+
+    should_validate_presence_of :user => [:login, :password, :password_confirmation]
+    should_validate_uniqueness_of :user => [:login]
+
+    def test_authenticate
+      assert_equal @user, Cms::User.authenticate(@user.login, @user.password)
+      assert_nil Cms::User.authenticate(@user.login, 'FAIL')
+    end
+
+    def test_authenticate_expired_user
+      @user.disable!
+      assert_nil Cms::User.authenticate(@user.login, @user.password)
+    end
+
+    def test_expiration
+      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_active
+      assert Cms::User.active.all.include?(@user)
+
+      @user.update_attribute(:expires_at, 1.year.from_now)
+      assert Cms::User.active.all.include?(@user)
+    end
+
+    test "Disable should work regardless of time zone" do
+      Time.zone = "UTC"
+      @user.disable!
+      assert !Cms::User.active.all.include?(@user)
+
+      user2 = Factory(:user)
+      Time.zone = "Eastern Time (US & Canada)"
+      user2.disable!
+      assert !Cms::User.active.all.include?(user2)
+
+    end
+
+    def test_disable_enable
+      assert_nil @user.expires_at
+      assert !@user.expired?
+
+      assert Cms::User.active.all.include?(@user)
+
+      assert @user.disable!
+
+      assert @user.expires_at <= Time.now.utc
+      assert @user.expired?
+      assert !Cms::User.active.all.include?(@user)
+
+      @user.enable!
+
+      assert_nil @user.expires_at
+      assert !@user.expired?
+      assert Cms::User.active.all.include?(@user)
+    end
+
+    test "email validation" do
+      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
+
+    test "full name or login" do
+      login = 'robbo'
+      fn = 'Bob'
+      ln = 'Smith'
+      u = Factory.build(:user, :login => 'robbo', :first_name => nil, :last_name => nil)
+      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 "Registered User able_to_view? with String path" do
+      registered_user = Cms::User.new
+      viewable_section = Cms::Section.new
+      Cms::Section.expects(:find_by_path).with("/members").returns(viewable_section)
+      registered_user.expects(:viewable_sections).returns([viewable_section])
+
+      assert registered_user.able_to_view?("/members")
+    end
+
+    test "User can't view a nil section" do
+      user = Cms::User.new
+
+      Cms::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 = Cms::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 = Cms::User.new
+      assert(!user.cms_access?, "")
+    end
+
+
+  end
+
+
+  class PageEdittingPermissions < ActiveSupport::TestCase
+    def setup
+      @content_editor = Factory(:content_editor) # Create first, so it will have permission to edit root section
+
+      given_a_site_exists
+      @private_section = Factory(:section, :parent => root_section)
+      @private_page = Factory(:public_page, :section => @private_section)
+      @editable_page = Factory(:public_page, :section => root_section)
+    end
+
+    test "#modifiable_sections" do
+      assert @content_editor.modifiable_sections.include?(root_section)
+      refute @content_editor.modifiable_sections.include?(@private_section)
+    end
+
+    test "#able_to_modify?" do
+      assert_equal false, @content_editor.able_to_modify?(@private_page)
+      assert_equal true, @content_editor.able_to_modify?(@editable_page)
+    end
+
+    test "#able_to_edit" do
+      assert_equal false, @content_editor.able_to_edit?(@private_page)
+      assert_equal true, @content_editor.able_to_edit?(@editable_page)
+    end
+
+    test "#able_to_publish?" do
+      assert_equal false, @content_editor.able_to_publish?(@private_page)
+      assert_equal true, @content_editor.able_to_publish?(@editable_page)
+    end
+  end
+
+  class UserPermissionsTest < ActiveSupport::TestCase
+    def setup
+      @user = Factory(:user)
+      @guest_group = Cms::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_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 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
+      @guest_group = given_there_is_a_guest_group
+      @guest_user = Cms::User.guest
+      @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 @guest_user.guest?
+      assert_equal @guest_group, @guest_user.group
+      assert @guest_user.groups.include?(@guest_group)
+      assert !@guest_user.able_to?("do anything global")
+      assert !@guest_user.able_to_view?(@protected_page)
+      assert !@guest_user.cms_access?
+    end
+
+    test "guest users should be able to see pages in public sections" do
+      root_section.allow_groups = :all
+      assert @guest_user.able_to_view?(@public_page)
+    end
+
+    test "override viewable sections for the guest group" do
+      @guest_user.expects(:viewable_sections).returns([@protected_section])
+      assert_equal Cms::Section, @protected_section.class
+      assert(@protected_section.is_a?(Cms::Section), "")
+      assert @guest_user.able_to_view?(@protected_section)
+    end
+
+    test "GuestUser can't view a nil section" do
+      user = Cms::GuestUser.new
+
+      Cms::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
+      expected_section = Cms::Section.new
+
+      Cms::Section.expects(:find_by_path).with("/members").returns(expected_section)
+      @guest_user.expects(:viewable_sections).returns([expected_section])
+
+      assert @guest_user.able_to_view?("/members")
+
+    end
+
+    test "Group.guest should be created during setup." do
+      assert_not_nil Cms::Group.guest, "Expected to be in the database for tests in this class."
+    end
+
+  end
+end

data/test/unit/schema_statements_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+class SchemaStatementsTest < ActiveSupport::TestCase
+
+  def ensure_no_prefix
+    Cms.expects(:table_prefix).returns("").at_least(0)
+  end
+
+  def setup
+    ensure_no_prefix()
+    %w(fake_contents).each do |t|
+      ActiveRecord::Base.connection.drop_content_table(t) rescue nil
+      ActiveRecord::Base.connection.drop_table(t) rescue nil
+    end
+
+  end
+
+  test "Removed ability to explicitly set :version_foreign_key in bcms 3.4. Should silently do nothing" do
+    class ::Cms::ExplictColumnBlock < ActiveRecord::Base
+      acts_as_content_block :versioned=>{:version_foreign_key => :something_id }
+    end
+    connection.drop_content_table :explict_column_blocks rescue nil
+    connection.create_content_table :explict_column_blocks, :prefix=>false do |t| ; end
+
+    assert_column_exists :explict_column_block_versions, :original_record_id
+    assert_column_does_not_exist :explict_column_block_versions, :something_id
+  end
+
+  test "Nonversioned blocks shouldn't create versions table" do
+    ensure_no_prefix()
+
+    class ::Cms::NonVersionedBlock < ActiveRecord::Base
+      acts_as_content_block :versioned=>false
+    end
+    connection.drop_table :non_versioned_blocks rescue nil
+    connection.drop_table :non_versioned_block_versions rescue nil
+    connection.create_content_table :non_versioned_blocks, :prefix=>false, :versioned=>false do |t| ; end
+
+    assert_equal false, ActiveRecord::Base.connection.table_exists?(:non_versioned_block_versions)
+  end
+
+
+  test "Create default versioned column, even if the record isn't marked versions (handles subclasses)" do
+    class ::Cms::PossiblyVersionedBlock < ActiveRecord::Base
+    end
+    connection.drop_table :possibly_versioned_blocks rescue nil
+    connection.drop_table :possibly_versioned_block_versions rescue nil
+    connection.create_content_table :possibly_versioned_blocks, :prefix=>false do |t| ; end
+
+    assert_column_exists :possibly_versioned_block_versions, :original_record_id
+  end
+
+  test "non-existant models should create default versions table." do
+    ensure_no_prefix()
+
+    connection.drop_table :non_existant_blocks rescue nil
+    connection.drop_table :non_existant_block_versions rescue nil
+    connection.create_content_table :non_existant_blocks, :prefix=>false do |t| ; end
+
+    assert_column_exists :non_existant_block_versions, :original_record_id
+  end
+
+  test "prefixed" do
+    Cms.expects(:table_prefix).returns("abc_")
+
+    result = ""
+    ActiveRecord::Base.connection.instance_eval do
+      result = prefix("stuff")
+    end
+
+    assert_equal "abc_stuff", result
+  end
+
+  test "create_content_table should make two tables" do
+    conn = ActiveRecord::Base.connection
+    conn.create_content_table :fake_contents, :prefix=>false do |t|
+      t.string :name
+    end
+
+    expected_columns = %w(archived created_at created_by_id deleted id lock_version name published updated_at updated_by_id version)
+    expected_columns_v = %w(archived created_at created_by_id deleted id name original_record_id published updated_at updated_by_id version version_comment)
+    assert_equal expected_columns, conn.columns(:fake_contents).map { |c| c.name }.sort
+    assert_equal expected_columns_v, conn.columns(:fake_content_versions).map { |c| c.name }.sort
+  end
+
+  test "add_content_column should add columns to both primary and versions table" do
+
+    connection.create_content_table :fake_contents, :prefix=>false do |t|; end
+
+    connection.add_content_column :fake_contents, :foo, :string
+
+    found_c = connection.columns(:fake_contents).map { |c| c.name }
+    assert found_c.include?("foo")
+
+    found_c = connection.columns(:fake_content_versions).map { |c| c.name }
+    assert found_c.include?("foo")
+  end
+
+  test "create_content_table should automatically add prefix" do
+    Cms.expects(:table_prefix).returns("abc_").at_least_once
+
+    ActiveRecord::Base.connection.instance_eval do
+      drop_table('abc_add_prefix') rescue nil
+      drop_table('abc_add_prefix_versions') rescue nil
+      create_content_table 'add_prefix' do |t|  ;  end
+    end
+
+    assert_table_was_created('abc_add_prefix')
+  end
+
+  test "Can optionally not create prefixed table" do
+    Cms.expects(:table_prefix).never
+
+    name = 'stuff'
+    ActiveRecord::Base.connection.instance_eval do
+      drop_table("stuff_versions") if table_exists?("stuff_versions")
+      drop_table("stuff") if table_exists?("stuff")
+      create_content_table name, :prefix=>false do |t|
+      end
+    end
+
+    assert_table_was_created('stuff')
+  end
+
+  private
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  def assert_table_was_created(table_name)
+    result = connection.execute("show tables like '#{table_name}'")
+    assert_equal 1, result.count, "Ensure the table was crated. (Might fail when running unit tests with drivers other than mysql2)"
+  end
+end
+
+