browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/models/user_test.rb

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

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