jro_apps/redmine Commit - r8968:80663e694dc2

Removed shoulda assertions....

Jean-Philippe Lang -

r8968:80663e694dc2

parent child

Context file:

r8968:80663e694dc2

Collapse all files

test/unit/project_test.rb 0 -29

              # Redmine - project management software
              # Copyright (C) 2006-2011  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class ProjectTest < ActiveSupport::TestCase
                fixtures :projects, :trackers, :issue_statuses, :issues,
                         :journals, :journal_details,
                         :enumerations, :users, :issue_categories,
                         :projects_trackers,
                         :custom_fields,
                         :custom_fields_projects,
                         :custom_fields_trackers,
                         :custom_values,
                         :roles,
                         :member_roles,
                         :members,
                         :enabled_modules,
                         :workflows,
                         :versions,
                         :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                         :groups_users,
                         :boards,
                         :repositories
                def setup
                  @ecookbook = Project.find(1)
                  @ecookbook_sub1 = Project.find(3)
                  set_tmp_attachments_directory
                  User.current = nil
                end
-               should_validate_presence_of :name
-               should_validate_presence_of :identifier
-               should_validate_uniqueness_of :identifier
-               context "associations" do
-                 should_have_many :members
-                 should_have_many :users, :through => :members
-                 should_have_many :member_principals
-                 should_have_many :principals, :through => :member_principals
-                 should_have_many :enabled_modules
-                 should_have_many :issues
-                 should_have_many :issue_changes, :through => :issues
-                 should_have_many :versions
-                 should_have_many :time_entries
-                 should_have_many :queries
-                 should_have_many :documents
-                 should_have_many :news
-                 should_have_many :issue_categories
-                 should_have_many :boards
-                 should_have_many :changesets, :through => :repository
-                 should_have_one :repository
-                 should_have_one :wiki
-                 should_have_and_belong_to_many :trackers
-                 should_have_and_belong_to_many :issue_custom_fields
-               end
                def test_truth
                  assert_kind_of Project, @ecookbook
                  assert_equal "eCookbook", @ecookbook.name
                end
                def test_default_attributes
                  with_settings :default_projects_public => '1' do
                    assert_equal true, Project.new.is_public
                    assert_equal false, Project.new(:is_public => false).is_public
                  end
                  with_settings :default_projects_public => '0' do
                    assert_equal false, Project.new.is_public
                    assert_equal true, Project.new(:is_public => true).is_public
                  end
                  with_settings :sequential_project_identifiers => '1' do
                    assert !Project.new.identifier.blank?
                    assert Project.new(:identifier => '').identifier.blank?
                  end
                  with_settings :sequential_project_identifiers => '0' do
                    assert Project.new.identifier.blank?
                    assert !Project.new(:identifier => 'test').blank?
                  end
                  with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                    assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names
                  end
                  assert_equal Tracker.all.sort, Project.new.trackers.sort
                  assert_equal Tracker.find(1, 3).sort, Project.new(:tracker_ids => [1, 3]).trackers.sort
                end
                def test_update
                  assert_equal "eCookbook", @ecookbook.name
                  @ecookbook.name = "eCook"
                  assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
                  @ecookbook.reload
                  assert_equal "eCook", @ecookbook.name
                end
                def test_validate_identifier
                  to_test = {"abc" => true,
                             "ab12" => true,
                             "ab-12" => true,
                             "ab_12" => true,
                             "12" => false,
                             "new" => false}
                  to_test.each do |identifier, valid|
                    p = Project.new
                    p.identifier = identifier
                    p.valid?
                    if valid
                      assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"
                    else
                      assert p.errors['identifier'].present?, "identifier #{identifier} was valid"
                    end
                  end
                end
                def test_members_should_be_active_users
                  Project.all.each do |project|
                    assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }
                  end
                end
                def test_users_should_be_active_users
                  Project.all.each do |project|
                    assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }
                  end
                end
                def test_archive
                  user = @ecookbook.members.first.user
                  @ecookbook.archive
                  @ecookbook.reload
                  assert !@ecookbook.active?
                  assert @ecookbook.archived?
                  assert !user.projects.include?(@ecookbook)
                  # Subproject are also archived
                  assert !@ecookbook.children.empty?
                  assert @ecookbook.descendants.active.empty?
                end
                def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects
                  # Assign an issue of a project to a version of a child project
                  Issue.find(4).update_attribute :fixed_version_id, 4
                  assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do
                    assert_equal false, @ecookbook.archive
                  end
                  @ecookbook.reload
                  assert @ecookbook.active?
                end
                def test_unarchive
                  user = @ecookbook.members.first.user
                  @ecookbook.archive
                  # A subproject of an archived project can not be unarchived
                  assert !@ecookbook_sub1.unarchive
                  # Unarchive project
                  assert @ecookbook.unarchive
                  @ecookbook.reload
                  assert @ecookbook.active?
                  assert !@ecookbook.archived?
                  assert user.projects.include?(@ecookbook)
                  # Subproject can now be unarchived
                  @ecookbook_sub1.reload
                  assert @ecookbook_sub1.unarchive
                end
                def test_destroy
                  # 2 active members
                  assert_equal 2, @ecookbook.members.size
                  # and 1 is locked
                  assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size
                  # some boards
                  assert @ecookbook.boards.any?
                  @ecookbook.destroy
                  # make sure that the project non longer exists
                  assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
                  # make sure related data was removed
                  assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})
                  assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})
                  assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})
                end
                def test_destroying_root_projects_should_clear_data
                  Project.roots.each do |root|
                    root.destroy
                  end
                  assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"
                  assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"
                  assert_equal 0, MemberRole.count
                  assert_equal 0, Issue.count
                  assert_equal 0, Journal.count
                  assert_equal 0, JournalDetail.count
                  assert_equal 0, Attachment.count
                  assert_equal 0, EnabledModule.count
                  assert_equal 0, IssueCategory.count
                  assert_equal 0, IssueRelation.count
                  assert_equal 0, Board.count
                  assert_equal 0, Message.count
                  assert_equal 0, News.count
                  assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")
                  assert_equal 0, Repository.count
                  assert_equal 0, Changeset.count
                  assert_equal 0, Change.count
                  assert_equal 0, Comment.count
                  assert_equal 0, TimeEntry.count
                  assert_equal 0, Version.count
                  assert_equal 0, Watcher.count
                  assert_equal 0, Wiki.count
                  assert_equal 0, WikiPage.count
                  assert_equal 0, WikiContent.count
                  assert_equal 0, WikiContent::Version.count
                  assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size
                  assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size
                  assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})
                end
                def test_move_an_orphan_project_to_a_root_project
                  sub = Project.find(2)
                  sub.set_parent! @ecookbook
                  assert_equal @ecookbook.id, sub.parent.id
                  @ecookbook.reload
                  assert_equal 4, @ecookbook.children.size
                end
                def test_move_an_orphan_project_to_a_subproject
                  sub = Project.find(2)
                  assert sub.set_parent!(@ecookbook_sub1)
                end
                def test_move_a_root_project_to_a_project
                  sub = @ecookbook
                  assert sub.set_parent!(Project.find(2))
                end
                def test_should_not_move_a_project_to_its_children
                  sub = @ecookbook
                  assert !(sub.set_parent!(Project.find(3)))
                end
                def test_set_parent_should_add_roots_in_alphabetical_order
                  ProjectCustomField.delete_all
                  Project.delete_all
                  Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
                  Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
                  Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
                  Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
                  assert_equal 4, Project.count
                  assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
                end
                def test_set_parent_should_add_children_in_alphabetical_order
                  ProjectCustomField.delete_all
                  parent = Project.create!(:name => 'Parent', :identifier => 'parent')
                  Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
                  Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
                  Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
                  Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
                  parent.reload
                  assert_equal 4, parent.children.size
                  assert_equal parent.children.all.sort_by(&:name), parent.children.all
                end
                def test_rebuild_should_sort_children_alphabetically
                  ProjectCustomField.delete_all
                  parent = Project.create!(:name => 'Parent', :identifier => 'parent')
                  Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)
                  Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)
                  Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)
                  Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)
                  Project.update_all("lft = NULL, rgt = NULL")
                  Project.rebuild!
                  parent.reload
                  assert_equal 4, parent.children.size
                  assert_equal parent.children.all.sort_by(&:name), parent.children.all
                end
                def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy
                  # Parent issue with a hierarchy project's fixed version
                  parent_issue = Issue.find(1)
                  parent_issue.update_attribute(:fixed_version_id, 4)
                  parent_issue.reload
                  assert_equal 4, parent_issue.fixed_version_id
                  # Should keep fixed versions for the issues
                  issue_with_local_fixed_version = Issue.find(5)
                  issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)
                  issue_with_local_fixed_version.reload
                  assert_equal 4, issue_with_local_fixed_version.fixed_version_id
                  # Local issue with hierarchy fixed_version
                  issue_with_hierarchy_fixed_version = Issue.find(13)
                  issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)
                  issue_with_hierarchy_fixed_version.reload
                  assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id
                  # Move project out of the issue's hierarchy
                  moved_project = Project.find(3)
                  moved_project.set_parent!(Project.find(2))
                  parent_issue.reload
                  issue_with_local_fixed_version.reload
                  issue_with_hierarchy_fixed_version.reload
                  assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"
                  assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"
                  assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."
                end
                def test_parent
                  p = Project.find(6).parent
                  assert p.is_a?(Project)
                  assert_equal 5, p.id
                end
                def test_ancestors
                  a = Project.find(6).ancestors
                  assert a.first.is_a?(Project)
                  assert_equal [1, 5], a.collect(&:id)
                end
                def test_root
                  r = Project.find(6).root
                  assert r.is_a?(Project)
                  assert_equal 1, r.id
                end
                def test_children
                  c = Project.find(1).children
                  assert c.first.is_a?(Project)
                  assert_equal [5, 3, 4], c.collect(&:id)
                end
                def test_descendants
                  d = Project.find(1).descendants
                  assert d.first.is_a?(Project)
                  assert_equal [5, 6, 3, 4], d.collect(&:id)
                end
                def test_allowed_parents_should_be_empty_for_non_member_user
                  Role.non_member.add_permission!(:add_project)
                  user = User.find(9)
                  assert user.memberships.empty?
                  User.current = user
                  assert Project.new.allowed_parents.compact.empty?
                end
                def test_allowed_parents_with_add_subprojects_permission
                  Role.find(1).remove_permission!(:add_project)
                  Role.find(1).add_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert !Project.new.allowed_parents.include?(nil)
                  assert Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert !Project.find(3).allowed_parents.include?(nil)
                end
                def test_allowed_parents_with_add_project_permission
                  Role.find(1).add_permission!(:add_project)
                  Role.find(1).remove_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert Project.new.allowed_parents.include?(nil)
                  assert !Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert Project.find(3).allowed_parents.include?(nil)
                end
                def test_allowed_parents_with_add_project_and_subprojects_permission
                  Role.find(1).add_permission!(:add_project)
                  Role.find(1).add_permission!(:add_subprojects)
                  User.current = User.find(2)
                  # new project
                  assert Project.new.allowed_parents.include?(nil)
                  assert Project.new.allowed_parents.include?(Project.find(1))
                  # existing root project
                  assert Project.find(1).allowed_parents.include?(nil)
                  # existing child
                  assert Project.find(3).allowed_parents.include?(Project.find(1))
                  assert Project.find(3).allowed_parents.include?(nil)
                end
                def test_users_by_role
                  users_by_role = Project.find(1).users_by_role
                  assert_kind_of Hash, users_by_role
                  role = Role.find(1)
                  assert_kind_of Array, users_by_role[role]
                  assert users_by_role[role].include?(User.find(2))
                end
                def test_rolled_up_trackers
                  parent = Project.find(1)
                  parent.trackers = Tracker.find([1,2])
                  child = parent.children.find(3)
                  assert_equal [1, 2], parent.tracker_ids
                  assert_equal [2, 3], child.trackers.collect(&:id)
                  assert_kind_of Tracker, parent.rolled_up_trackers.first
                  assert_equal Tracker.find(1), parent.rolled_up_trackers.first
                  assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
                  assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
                end
                def test_rolled_up_trackers_should_ignore_archived_subprojects
                  parent = Project.find(1)
                  parent.trackers = Tracker.find([1,2])
                  child = parent.children.find(3)
                  child.trackers = Tracker.find([1,3])
                  parent.children.each(&:archive)
                  assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)
                end
                context "#rolled_up_versions" do
                  setup do
                    @project = Project.generate!
                    @parent_version_1 = Version.generate!(:project => @project)
                    @parent_version_2 = Version.generate!(:project => @project)
                  end
                  should "include the versions for the current project" do
                    assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
                  end
                  should "include versions for a subproject" do
                    @subproject = Project.generate!
                    @subproject.set_parent!(@project)
                    @subproject_version = Version.generate!(:project => @subproject)
                    assert_same_elements [
                                          @parent_version_1,
                                          @parent_version_2,
                                          @subproject_version
                                         ], @project.rolled_up_versions
                  end
                  should "include versions for a sub-subproject" do
                    @subproject = Project.generate!
                    @subproject.set_parent!(@project)
                    @sub_subproject = Project.generate!
                    @sub_subproject.set_parent!(@subproject)
                    @sub_subproject_version = Version.generate!(:project => @sub_subproject)
                    @project.reload
                    assert_same_elements [
                                          @parent_version_1,
                                          @parent_version_2,
                                          @sub_subproject_version
                                         ], @project.rolled_up_versions
                  end
                  should "only check active projects" do
                    @subproject = Project.generate!
                    @subproject.set_parent!(@project)
                    @subproject_version = Version.generate!(:project => @subproject)
                    assert @subproject.archive
                    @project.reload
                    assert !@subproject.active?
                    assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
                  end
                end
                def test_shared_versions_none_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')
                  assert p.shared_versions.include?(v)
                  assert !p.children.first.shared_versions.include?(v)
                  assert !p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_descendants_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert !p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_hierarchy_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert !p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_tree_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert p.siblings.first.shared_versions.include?(v)
                  assert !p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions_system_sharing
                  p = Project.find(5)
                  v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                  assert p.shared_versions.include?(v)
                  assert p.children.first.shared_versions.include?(v)
                  assert p.root.shared_versions.include?(v)
                  assert p.siblings.first.shared_versions.include?(v)
                  assert p.root.siblings.first.shared_versions.include?(v)
                end
                def test_shared_versions
                  parent = Project.find(1)
                  child = parent.children.find(3)
                  private_child = parent.children.find(5)
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [4], child.version_ids
                  assert_equal [6], private_child.version_ids
                  assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)
                  assert_equal 6, parent.shared_versions.size
                  parent.shared_versions.each do |version|
                    assert_kind_of Version, version
                  end
                  assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort
                end
                def test_shared_versions_should_ignore_archived_subprojects
                  parent = Project.find(1)
                  child = parent.children.find(3)
                  child.archive
                  parent.reload
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [4], child.version_ids
                  assert !parent.shared_versions.collect(&:id).include?(4)
                end
                def test_shared_versions_visible_to_user
                  user = User.find(3)
                  parent = Project.find(1)
                  child = parent.children.find(5)
                  assert_equal [1,2,3], parent.version_ids.sort
                  assert_equal [6], child.version_ids
                  versions = parent.shared_versions.visible(user)
                  assert_equal 4, versions.size
                  versions.each do |version|
                    assert_kind_of Version, version
                  end
                  assert !versions.collect(&:id).include?(6)
                end
                def test_shared_versions_for_new_project_should_include_system_shared_versions
                  p = Project.find(5)
                  v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                  assert_include v, Project.new.shared_versions
                end
                def test_next_identifier
                  ProjectCustomField.delete_all
                  Project.create!(:name => 'last', :identifier => 'p2008040')
                  assert_equal 'p2008041', Project.next_identifier
                end
                def test_next_identifier_first_project
                  Project.delete_all
                  assert_nil Project.next_identifier
                end
                def test_enabled_module_names
                  with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                    project = Project.new
                    project.enabled_module_names = %w(issue_tracking news)
                    assert_equal %w(issue_tracking news), project.enabled_module_names.sort
                  end
                end
                context "enabled_modules" do
                  setup do
                    @project = Project.find(1)
                  end
                  should "define module by names and preserve ids" do
                    # Remove one module
                    modules = @project.enabled_modules.slice(0..-2)
                    assert modules.any?
                    assert_difference 'EnabledModule.count', -1 do
                      @project.enabled_module_names = modules.collect(&:name)
                    end
                    @project.reload
                    # Ids should be preserved
                    assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
                  end
                  should "enable a module" do
                    @project.enabled_module_names = []
                    @project.reload
                    assert_equal [], @project.enabled_module_names
                    #with string
                    @project.enable_module!("issue_tracking")
                    assert_equal ["issue_tracking"], @project.enabled_module_names
                    #with symbol
                    @project.enable_module!(:gantt)
                    assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                    #don't add a module twice
                    @project.enable_module!("issue_tracking")
                    assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                  end
                  should "disable a module" do
                    #with string
                    assert @project.enabled_module_names.include?("issue_tracking")
                    @project.disable_module!("issue_tracking")
                    assert ! @project.reload.enabled_module_names.include?("issue_tracking")
                    #with symbol
                    assert @project.enabled_module_names.include?("gantt")
                    @project.disable_module!(:gantt)
                    assert ! @project.reload.enabled_module_names.include?("gantt")
                    #with EnabledModule object
                    first_module = @project.enabled_modules.first
                    @project.disable_module!(first_module)
                    assert ! @project.reload.enabled_module_names.include?(first_module.name)
                  end
                end
                def test_enabled_module_names_should_not_recreate_enabled_modules
                  project = Project.find(1)
                  # Remove one module
                  modules = project.enabled_modules.slice(0..-2)
                  assert modules.any?
                  assert_difference 'EnabledModule.count', -1 do
                    project.enabled_module_names = modules.collect(&:name)
                  end
                  project.reload
                  # Ids should be preserved
                  assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort
                end
                def test_copy_from_existing_project
                  source_project = Project.find(1)
                  copied_project = Project.copy_from(1)
                  assert copied_project
                  # Cleared attributes
                  assert copied_project.id.blank?
                  assert copied_project.name.blank?
                  assert copied_project.identifier.blank?
                  # Duplicated attributes
                  assert_equal source_project.description, copied_project.description
                  assert_equal source_project.enabled_modules, copied_project.enabled_modules
                  assert_equal source_project.trackers, copied_project.trackers
                  # Default attributes
                  assert_equal 1, copied_project.status
                end
                def test_activities_should_use_the_system_activities
                  project = Project.find(1)
                  assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )
                end
                def test_activities_should_use_the_project_specific_activities
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})
                  assert overridden_activity.save!
                  assert project.activities.include?(overridden_activity), "Project specific Activity not found"
                end
                def test_activities_should_not_include_the_inactive_project_specific_activities
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"
                end
                def test_activities_should_not_include_project_specific_activities_from_other_projects
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"
                end
                def test_activities_should_handle_nils
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.find(:first)})
                  TimeEntryActivity.delete_all
                  # No activities
                  project = Project.find(1)
                  assert project.activities.empty?
                  # No system, one overridden
                  assert overridden_activity.save!
                  project.reload
                  assert_equal [overridden_activity], project.activities
                end
                def test_activities_should_override_system_activities_with_project_activities
                  project = Project.find(1)
                  parent_activity = TimeEntryActivity.find(:first)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})
                  assert overridden_activity.save!
                  assert project.activities.include?(overridden_activity), "Project specific Activity not found"
                  assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"
                end
                def test_activities_should_include_inactive_activities_if_specified
                  project = Project.find(1)
                  overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
                  assert overridden_activity.save!
                  assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"
                end
                test 'activities should not include active System activities if the project has an override that is inactive' do
                  project = Project.find(1)
                  system_activity = TimeEntryActivity.find_by_name('Design')
                  assert system_activity.active?
                  overridden_activity = TimeEntryActivity.generate!(:project => project, :parent => system_activity, :active => false)
                  assert overridden_activity.save!
                  assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
                  assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"
                end
                def test_close_completed_versions
                  Version.update_all("status = 'open'")
                  project = Project.find(1)
                  assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}
                  assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
                  project.close_completed_versions
                  project.reload
                  assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}
                  assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
                end
                context "Project#copy" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    Project.destroy_all :identifier => "copy-test"
                    @source_project = Project.find(2)
                    @project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')
                    @project.trackers = @source_project.trackers
                    @project.enabled_module_names = @source_project.enabled_modules.collect(&:name)
                  end
                  should "copy issues" do
                    @source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),
                                                              :subject => "copy issue status",
                                                              :tracker_id => 1,
                                                              :assigned_to_id => 2,
                                                              :project_id => @source_project.id)
                    assert @project.valid?
                    assert @project.issues.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.issues.size, @project.issues.size
                    @project.issues.each do |issue|
                      assert issue.valid?
                      assert ! issue.assigned_to.blank?
                      assert_equal @project, issue.project
                    end
                    copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})
                    assert copied_issue
                    assert copied_issue.status
                    assert_equal "Closed", copied_issue.status.name
                  end
                  should "change the new issues to use the copied version" do
                    User.current = User.find(1)
                    assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')
                    @source_project.versions << assigned_version
                    assert_equal 3, @source_project.versions.size
                    Issue.generate_for_project!(@source_project,
                                                :fixed_version_id => assigned_version.id,
                                                :subject => "change the new issues to use the copied version",
                                                :tracker_id => 1,
                                                :project_id => @source_project.id)
                    assert @project.copy(@source_project)
                    @project.reload
                    copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})
                    assert copied_issue
                    assert copied_issue.fixed_version
                    assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
                    assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record
                  end
                  should "copy issue relations" do
                    Setting.cross_project_issue_relations = '1'
                    second_issue = Issue.generate!(:status_id => 5,
                                                   :subject => "copy issue relation",
                                                   :tracker_id => 1,
                                                   :assigned_to_id => 2,
                                                   :project_id => @source_project.id)
                    source_relation = IssueRelation.generate!(:issue_from => Issue.find(4),
                                                              :issue_to => second_issue,
                                                              :relation_type => "relates")
                    source_relation_cross_project = IssueRelation.generate!(:issue_from => Issue.find(1),
                                                                            :issue_to => second_issue,
                                                                            :relation_type => "duplicates")
                    assert @project.copy(@source_project)
                    assert_equal @source_project.issues.count, @project.issues.count
                    copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4
                    copied_second_issue = @project.issues.find_by_subject("copy issue relation")
                    # First issue with a relation on project
                    assert_equal 1, copied_issue.relations.size, "Relation not copied"
                    copied_relation = copied_issue.relations.first
                    assert_equal "relates", copied_relation.relation_type
                    assert_equal copied_second_issue.id, copied_relation.issue_to_id
                    assert_not_equal source_relation.id, copied_relation.id
                    # Second issue with a cross project relation
                    assert_equal 2, copied_second_issue.relations.size, "Relation not copied"
                    copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first
                    assert_equal "duplicates", copied_relation.relation_type
                    assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"
                    assert_not_equal source_relation_cross_project.id, copied_relation.id
                  end
                  should "copy issue attachments" do
                    issue = Issue.generate!(:subject => "copy with attachment", :tracker_id => 1, :project_id => @source_project.id)
                    Attachment.create!(:container => issue, :file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 1)
                    @source_project.issues << issue
                    assert @project.copy(@source_project)
                    copied_issue = @project.issues.first(:conditions => {:subject => "copy with attachment"})
                    assert_not_nil copied_issue
                    assert_equal 1, copied_issue.attachments.count, "Attachment not copied"
                    assert_equal "testfile.txt", copied_issue.attachments.first.filename
                  end
                  should "copy memberships" do
                    assert @project.valid?
                    assert @project.members.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.memberships.size, @project.memberships.size
                    @project.memberships.each do |membership|
                      assert membership
                      assert_equal @project, membership.project
                    end
                  end
                  should "copy memberships with groups and additional roles" do
                    group = Group.create!(:lastname => "Copy group")
                    user = User.find(7)
                    group.users << user
                    # group role
                    Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])
                    member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)
                    # additional role
                    member.role_ids = [1]
                    assert @project.copy(@source_project)
                    member = Member.find_by_user_id_and_project_id(user.id, @project.id)
                    assert_not_nil member
                    assert_equal [1, 2], member.role_ids.sort
                  end
                  should "copy project specific queries" do
                    assert @project.valid?
                    assert @project.queries.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.queries.size, @project.queries.size
                    @project.queries.each do |query|
                      assert query
                      assert_equal @project, query.project
                    end
                    assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort
                  end
                  should "copy versions" do
                    @source_project.versions << Version.generate!
                    @source_project.versions << Version.generate!
                    assert @project.versions.empty?
                    assert @project.copy(@source_project)
                    assert_equal @source_project.versions.size, @project.versions.size
                    @project.versions.each do |version|
                      assert version
                      assert_equal @project, version.project
                    end
                  end
                  should "copy wiki" do
                    assert_difference 'Wiki.count' do
                      assert @project.copy(@source_project)
                    end
                    assert @project.wiki
                    assert_not_equal @source_project.wiki, @project.wiki
                    assert_equal "Start page", @project.wiki.start_page
                  end
                  should "copy wiki pages and content with hierarchy" do
                    assert_difference 'WikiPage.count', @source_project.wiki.pages.size do
                      assert @project.copy(@source_project)
                    end
                    assert @project.wiki
                    assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size
                    @project.wiki.pages.each do |wiki_page|
                      assert wiki_page.content
                      assert !@source_project.wiki.pages.include?(wiki_page)
                    end
                    parent = @project.wiki.find_page('Parent_page')
                    child1 = @project.wiki.find_page('Child_page_1')
                    child2 = @project.wiki.find_page('Child_page_2')
                    assert_equal parent, child1.parent
                    assert_equal parent, child2.parent
                  end
                  should "copy issue categories" do
                    assert @project.copy(@source_project)
                    assert_equal 2, @project.issue_categories.size
                    @project.issue_categories.each do |issue_category|
                      assert !@source_project.issue_categories.include?(issue_category)
                    end
                  end
                  should "copy boards" do
                    assert @project.copy(@source_project)
                    assert_equal 1, @project.boards.size
                    @project.boards.each do |board|
                      assert !@source_project.boards.include?(board)
                    end
                  end
                  should "change the new issues to use the copied issue categories" do
                    issue = Issue.find(4)
                    issue.update_attribute(:category_id, 3)
                    assert @project.copy(@source_project)
                    @project.issues.each do |issue|
                      assert issue.category
                      assert_equal "Stock management", issue.category.name # Same name
                      assert_not_equal IssueCategory.find(3), issue.category # Different record
                    end
                  end
                  should "limit copy with :only option" do
                    assert @project.members.empty?
                    assert @project.issue_categories.empty?
                    assert @source_project.issues.any?
                    assert @project.copy(@source_project, :only => ['members', 'issue_categories'])
                    assert @project.members.any?
                    assert @project.issue_categories.any?
                    assert @project.issues.empty?
                  end
                end
                context "#start_date" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  should "be nil if there are no issues on the project" do
                    assert_nil @project.start_date
                  end
                  should "be tested when issues have no start date"
                  should "be the earliest start date of it's issues" do
                    early = 7.days.ago.to_date
                    Issue.generate_for_project!(@project, :start_date => Date.today)
                    Issue.generate_for_project!(@project, :start_date => early)
                    assert_equal early, @project.start_date
                  end
                end
                context "#due_date" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  should "be nil if there are no issues on the project" do
                    assert_nil @project.due_date
                  end
                  should "be tested when issues have no due date"
                  should "be the latest due date of it's issues" do
                    future = 7.days.from_now.to_date
                    Issue.generate_for_project!(@project, :due_date => future)
                    Issue.generate_for_project!(@project, :due_date => Date.today)
                    assert_equal future, @project.due_date
                  end
                  should "be the latest due date of it's versions" do
                    future = 7.days.from_now.to_date
                    @project.versions << Version.generate!(:effective_date => future)
                    @project.versions << Version.generate!(:effective_date => Date.today)
                    assert_equal future, @project.due_date
                  end
                  should "pick the latest date from it's issues and versions" do
                    future = 7.days.from_now.to_date
                    far_future = 14.days.from_now.to_date
                    Issue.generate_for_project!(@project, :due_date => far_future)
                    @project.versions << Version.generate!(:effective_date => future)
                    assert_equal far_future, @project.due_date
                  end
                end
                context "Project#completed_percent" do
                  setup do
                    ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                    @project = Project.generate!(:identifier => 'test0')
                    @project.trackers << Tracker.generate!
                  end
                  context "no versions" do
                    should "be 100" do
                      assert_equal 100, @project.completed_percent
                    end
                  end
                  context "with versions" do
                    should "return 0 if the versions have no issues" do
                      Version.generate!(:project => @project)
                      Version.generate!(:project => @project)
                      assert_equal 0, @project.completed_percent
                    end
                    should "return 100 if the version has only closed issues" do
                      v1 = Version.generate!(:project => @project)
                      Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
                      v2 = Version.generate!(:project => @project)
                      Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
                      assert_equal 100, @project.completed_percent
                    end
                    should "return the averaged completed percent of the versions (not weighted)" do
                      v1 = Version.generate!(:project => @project)
                      Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
                      v2 = Version.generate!(:project => @project)
                      Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
                      assert_equal 50, @project.completed_percent
                    end
                  end
                end
                context "#notified_users" do
                  setup do
                    @project = Project.generate!
                    @role = Role.generate!
                    @user_with_membership_notification = User.generate!(:mail_notification => 'selected')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
                    @all_events_user = User.generate!(:mail_notification => 'all')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @all_events_user)
                    @no_events_user = User.generate!(:mail_notification => 'none')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @no_events_user)
                    @only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
                    @only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
                    @only_owned_user = User.generate!(:mail_notification => 'only_owner')
                    Member.generate!(:project => @project, :roles => [@role], :principal => @only_owned_user)
                  end
                  should "include members with a mail notification" do
                    assert @project.notified_users.include?(@user_with_membership_notification)
                  end
                  should "include users with the 'all' notification option" do
                    assert @project.notified_users.include?(@all_events_user)
                  end
                  should "not include users with the 'none' notification option" do
                    assert !@project.notified_users.include?(@no_events_user)
                  end
                  should "not include users with the 'only_my_events' notification option" do
                    assert !@project.notified_users.include?(@only_my_events_user)
                  end
                  should "not include users with the 'only_assigned' notification option" do
                    assert !@project.notified_users.include?(@only_assigned_user)
                  end
                  should "not include users with the 'only_owner' notification option" do
                    assert !@project.notified_users.include?(@only_owned_user)
                  end
                end
              end

test/unit/user_test.rb 0 -5

              # Redmine - project management software
              # Copyright (C) 2006-2011  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require File.expand_path('../../test_helper', __FILE__)
              class UserTest < ActiveSupport::TestCase
                fixtures :users, :members, :projects, :roles, :member_roles, :auth_sources,
                          :trackers, :issue_statuses,
                          :projects_trackers,
                          :watchers,
                          :issue_categories, :enumerations, :issues,
                          :journals, :journal_details,
                          :groups_users,
                          :enabled_modules,
                          :workflows
                def setup
                  @admin = User.find(1)
                  @jsmith = User.find(2)
                  @dlopper = User.find(3)
                end
                test 'object_daddy creation' do
                  User.generate_with_protected!(:firstname => 'Testing connection')
                  User.generate_with_protected!(:firstname => 'Testing connection')
                  assert_equal 2, User.count(:all, :conditions => {:firstname => 'Testing connection'})
                end
                def test_truth
                  assert_kind_of User, @jsmith
                end
                def test_mail_should_be_stripped
                  u = User.new
                  u.mail = " foo@bar.com  "
                  assert_equal "foo@bar.com", u.mail
                end
                def test_mail_validation
                  u = User.new
                  u.mail = ''
                  assert !u.valid?
                  assert_equal I18n.translate('activerecord.errors.messages.blank'),
                               u.errors[:mail].to_s
                end
                def test_login_length_validation
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
                  assert !user.valid?
                  user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
                  assert user.valid?
                  assert user.save
                end
                def test_create
                  user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  user.login = "jsmith"
                  user.password, user.password_confirmation = "password", "password"
                  # login uniqueness
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.login = "newuser"
                  user.password, user.password_confirmation = "passwd", "password"
                  # password confirmation
                  assert !user.save
                  assert_equal 1, user.errors.count
                  user.password, user.password_confirmation = "password", "password"
                  assert user.save
                end
                context "User#before_create" do
                  should "set the mail_notification to the default Setting" do
                    @user1 = User.generate_with_protected!
                    assert_equal 'only_my_events', @user1.mail_notification
                    with_settings :default_notification_option => 'all' do
                      @user2 = User.generate_with_protected!
                      assert_equal 'all', @user2.mail_notification
                    end
                  end
                end
                context "User.login" do
                  should "be case-insensitive." do
                    u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                    u.login = 'newuser'
                    u.password, u.password_confirmation = "password", "password"
                    assert u.save
                    u = User.new(:firstname => "Similar", :lastname => "User", :mail => "similaruser@somenet.foo")
                    u.login = 'NewUser'
                    u.password, u.password_confirmation = "password", "password"
                    assert !u.save
                    assert_equal I18n.translate('activerecord.errors.messages.taken'),
                                 u.errors[:login].to_s
                  end
                end
                def test_mail_uniqueness_should_not_be_case_sensitive
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
                  u.login = 'newuser1'
                  u.password, u.password_confirmation = "password", "password"
                  assert u.save
                  u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
                  u.login = 'newuser2'
                  u.password, u.password_confirmation = "password", "password"
                  assert !u.save
                  assert_equal I18n.translate('activerecord.errors.messages.taken'),
                               u.errors[:mail].to_s
                end
                def test_update
                  assert_equal "admin", @admin.login
                  @admin.login = "john"
                  assert @admin.save, @admin.errors.full_messages.join("; ")
                  @admin.reload
                  assert_equal "john", @admin.login
                end
                def test_destroy_should_delete_members_and_roles
                  members = Member.find_all_by_user_id(2)
                  ms = members.size
                  rs = members.collect(&:roles).flatten.size
                  assert_difference 'Member.count', - ms do
                    assert_difference 'MemberRole.count', - rs do
                      User.find(2).destroy
                    end
                  end
                  assert_nil User.find_by_id(2)
                  assert Member.find_all_by_user_id(2).empty?
                end
                def test_destroy_should_update_attachments
                  attachment = Attachment.create!(:container => Project.find(1),
                    :file => uploaded_test_file("testfile.txt", "text/plain"),
                    :author_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, attachment.reload.author
                end
                def test_destroy_should_update_comments
                  comment = Comment.create!(
                    :commented => News.create!(:project_id => 1, :author_id => 1, :title => 'foo', :description => 'foo'),
                    :author => User.find(2),
                    :comments => 'foo'
                  )
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, comment.reload.author
                end
                def test_destroy_should_update_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.reload.author
                end
                def test_destroy_should_unassign_issues
                  issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil issue.reload.assigned_to
                end
                def test_destroy_should_update_journals
                  issue = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(2), "update")
                  issue.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, issue.journals.first.reload.user
                end
                def test_destroy_should_update_journal_details_old_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = nil
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.first(:order => 'id DESC')
                  assert_equal '2', journal_detail.old_value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
                end
                def test_destroy_should_update_journal_details_value
                  issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo')
                  issue.init_journal(User.find(1), "update")
                  issue.assigned_to_id = 2
                  assert_difference 'JournalDetail.count' do
                    issue.save!
                  end
                  journal_detail = JournalDetail.first(:order => 'id DESC')
                  assert_equal '2', journal_detail.value
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous.id.to_s, journal_detail.reload.value
                end
                def test_destroy_should_update_messages
                  board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
                  message = Message.create!(:board_id => board.id, :author_id => 2, :subject => 'foo', :content => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, message.reload.author
                end
                def test_destroy_should_update_news
                  news = News.create!(:project_id => 1, :author_id => 2, :title => 'foo', :description => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, news.reload.author
                end
                def test_destroy_should_delete_private_queries
                  query = Query.new(:name => 'foo', :is_public => false)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Query.find_by_id(query.id)
                end
                def test_destroy_should_update_public_queries
                  query = Query.new(:name => 'foo', :is_public => true)
                  query.project_id = 1
                  query.user_id = 2
                  query.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, query.reload.user
                end
                def test_destroy_should_update_time_entries
                  entry = TimeEntry.new(:hours => '2', :spent_on => Date.today, :activity => TimeEntryActivity.create!(:name => 'foo'))
                  entry.project_id = 1
                  entry.user_id = 2
                  entry.save!
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, entry.reload.user
                end
                def test_destroy_should_delete_tokens
                  token = Token.create!(:user_id => 2, :value => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Token.find_by_id(token.id)
                end
                def test_destroy_should_delete_watchers
                  issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo')
                  watcher = Watcher.create!(:user_id => 2, :watchable => issue)
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil Watcher.find_by_id(watcher.id)
                end
                def test_destroy_should_update_wiki_contents
                  wiki_content = WikiContent.create!(
                    :text => 'foo',
                    :author_id => 2,
                    :page => WikiPage.create!(:title => 'Foo', :wiki => Wiki.create!(:project_id => 1, :start_page => 'Start'))
                  )
                  wiki_content.text = 'bar'
                  assert_difference 'WikiContent::Version.count' do
                    wiki_content.save!
                  end
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_equal User.anonymous, wiki_content.reload.author
                  wiki_content.versions.each do |version|
                    assert_equal User.anonymous, version.reload.author
                  end
                end
                def test_destroy_should_nullify_issue_categories
                  category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil category.reload.assigned_to_id
                end
                def test_destroy_should_nullify_changesets
                  changeset = Changeset.create!(
                    :repository => Repository::Subversion.generate!(
                      :project_id => 1
                    ),
                    :revision => '12',
                    :committed_on => Time.now,
                    :committer => 'jsmith'
                    )
                  assert_equal 2, changeset.user_id
                  User.find(2).destroy
                  assert_nil User.find_by_id(2)
                  assert_nil changeset.reload.user_id
                end
                def test_anonymous_user_should_not_be_destroyable
                  assert_no_difference 'User.count' do
                    assert_equal false, User.anonymous.destroy
                  end
                end
                def test_validate_login_presence
                  @admin.login = ""
                  assert !@admin.save
                  assert_equal 1, @admin.errors.count
                end
                def test_validate_mail_notification_inclusion
                  u = User.new
                  u.mail_notification = 'foo'
                  u.save
                  assert_not_nil u.errors[:mail_notification]
                end
                context "User#try_to_login" do
                  should "fall-back to case-insensitive if user login is not found as-typed." do
                    user = User.try_to_login("AdMin", "admin")
                    assert_kind_of User, user
                    assert_equal "admin", user.login
                  end
                  should "select the exact matching user first" do
                    case_sensitive_user = User.generate_with_protected!(
                                                 :login => 'changed', :password => 'admin',
                                                 :password_confirmation => 'admin')
                    # bypass validations to make it appear like existing data
                    case_sensitive_user.update_attribute(:login, 'ADMIN')
                    user = User.try_to_login("ADMIN", "admin")
                    assert_kind_of User, user
                    assert_equal "ADMIN", user.login
                  end
                end
                def test_password
                  user = User.try_to_login("admin", "admin")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                  user.password = "hello"
                  assert user.save
                  user = User.try_to_login("admin", "hello")
                  assert_kind_of User, user
                  assert_equal "admin", user.login
                end
                def test_validate_password_length
                  with_settings :password_min_length => '100' do
                    user = User.new(:firstname => "new100", :lastname => "user100", :mail => "newuser100@somenet.foo")
                    user.login = "newuser100"
                    user.password, user.password_confirmation = "password100", "password100"
                    assert !user.save
                    assert_equal 1, user.errors.count
                  end
                end
                def test_name_format
                  assert_equal 'Smith, John', @jsmith.name(:lastname_coma_firstname)
                  with_settings :user_format => :firstname_lastname do
                    assert_equal 'John Smith', @jsmith.reload.name
                  end
                  with_settings :user_format => :username do
                    assert_equal 'jsmith', @jsmith.reload.name
                  end
                end
                def test_fields_for_order_statement_should_return_fields_according_user_format_setting
                  with_settings :user_format => 'lastname_coma_firstname' do
                    assert_equal ['users.lastname', 'users.firstname', 'users.id'], User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_width_table_name_should_prepend_table_name
                  with_settings :user_format => 'lastname_firstname' do
                    assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'], User.fields_for_order_statement('authors')
                  end
                end
                def test_fields_for_order_statement_with_blank_format_should_return_default
                  with_settings :user_format => '' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'], User.fields_for_order_statement
                  end
                end
                def test_fields_for_order_statement_with_invalid_format_should_return_default
                  with_settings :user_format => 'foo' do
                    assert_equal ['users.firstname', 'users.lastname', 'users.id'], User.fields_for_order_statement
                  end
                end
                def test_lock
                  user = User.try_to_login("jsmith", "jsmith")
                  assert_equal @jsmith, user
                  @jsmith.status = User::STATUS_LOCKED
                  assert @jsmith.save
                  user = User.try_to_login("jsmith", "jsmith")
                  assert_equal nil, user
                end
                context ".try_to_login" do
                  context "with good credentials" do
                    should "return the user" do
                      user = User.try_to_login("admin", "admin")
                      assert_kind_of User, user
                      assert_equal "admin", user.login
                    end
                  end
                  context "with wrong credentials" do
                    should "return nil" do
                      assert_nil User.try_to_login("admin", "foo")
                    end
                  end
                end
                if ldap_configured?
                  context "#try_to_login using LDAP" do
                    context "with failed connection to the LDAP server" do
                      should "return nil" do
                        @auth_source = AuthSourceLdap.find(1)
                        AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
                        assert_equal nil, User.try_to_login('edavis', 'wrong')
                      end
                    end
                    context "with an unsuccessful authentication" do
                      should "return nil" do
                        assert_equal nil, User.try_to_login('edavis', 'wrong')
                      end
                    end
                    context "on the fly registration" do
                      setup do
                        @auth_source = AuthSourceLdap.find(1)
                        @auth_source.update_attribute :onthefly_register, true
                      end
                      context "with a successful authentication" do
                        should "create a new user account if it doesn't exist" do
                          assert_difference('User.count') do
                            user = User.try_to_login('edavis', '123456')
                            assert !user.admin?
                          end
                        end
                        should "retrieve existing user" do
                          user = User.try_to_login('edavis', '123456')
                          user.admin = true
                          user.save!
                          assert_no_difference('User.count') do
                            user = User.try_to_login('edavis', '123456')
                            assert user.admin?
                          end
                        end
                      end
                    end
                  end
                else
                  puts "Skipping LDAP tests."
                end
                def test_create_anonymous
                  AnonymousUser.delete_all
                  anon = User.anonymous
                  assert !anon.new_record?
                  assert_kind_of AnonymousUser, anon
                end
                def test_ensure_single_anonymous_user
                  AnonymousUser.delete_all
                  anon1 = User.anonymous
                  assert !anon1.new_record?
                  assert_kind_of AnonymousUser, anon1
                  anon2 = AnonymousUser.create(
                              :lastname => 'Anonymous', :firstname => '',
                              :mail => '', :login => '', :status => 0)
                  assert_equal 1, anon2.errors.count
                end
-               should_have_one :rss_token
                def test_rss_key
                  assert_nil @jsmith.rss_token
                  key = @jsmith.rss_key
                  assert_equal 40, key.length
                  @jsmith.reload
                  assert_equal key, @jsmith.rss_key
                end
-               should_have_one :api_token
                context "User#api_key" do
                  should "generate a new one if the user doesn't have one" do
                    user = User.generate_with_protected!(:api_token => nil)
                    assert_nil user.api_token
                    key = user.api_key
                    assert_equal 40, key.length
                    user.reload
                    assert_equal key, user.api_key
                  end
                  should "return the existing api token value" do
                    user = User.generate_with_protected!
                    token = Token.generate!(:action => 'api')
                    user.api_token = token
                    assert user.save
                    assert_equal token.value, user.api_key
                  end
                end
                context "User#find_by_api_key" do
                  should "return nil if no matching key is found" do
                    assert_nil User.find_by_api_key('zzzzzzzzz')
                  end
                  should "return nil if the key is found for an inactive user" do
                    user = User.generate_with_protected!(:status => User::STATUS_LOCKED)
                    token = Token.generate!(:action => 'api')
                    user.api_token = token
                    user.save
                    assert_nil User.find_by_api_key(token.value)
                  end
                  should "return the user if the key is found for an active user" do
                    user = User.generate_with_protected!(:status => User::STATUS_ACTIVE)
                    token = Token.generate!(:action => 'api')
                    user.api_token = token
                    user.save
                    assert_equal user, User.find_by_api_key(token.value)
                  end
                end
                def test_roles_for_project
                  # user with a role
                  roles = @jsmith.roles_for_project(Project.find(1))
                  assert_kind_of Role, roles.first
                  assert_equal "Manager", roles.first.name
                  # user with no role
                  assert_nil @dlopper.roles_for_project(Project.find(2)).detect {|role| role.member?}
                end
                def test_projects_by_role_for_user_with_role
                  user = User.find(2)
                  assert_kind_of Hash, user.projects_by_role
                  assert_equal 2, user.projects_by_role.size
                  assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
                  assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
                end
                def test_projects_by_role_for_user_with_no_role
                  user = User.generate!
                  assert_equal({}, user.projects_by_role)
                end
                def test_projects_by_role_for_anonymous
                  assert_equal({}, User.anonymous.projects_by_role)
                end
                def test_valid_notification_options
                  # without memberships
                  assert_equal 5, User.find(7).valid_notification_options.size
                  # with memberships
                  assert_equal 6, User.find(2).valid_notification_options.size
                end
                def test_valid_notification_options_class_method
                  assert_equal 5, User.valid_notification_options.size
                  assert_equal 5, User.valid_notification_options(User.find(7)).size
                  assert_equal 6, User.valid_notification_options(User.find(2)).size
                end
                def test_mail_notification_all
                  @jsmith.mail_notification = 'all'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_selected
                  @jsmith.mail_notification = 'selected'
                  @jsmith.notified_project_ids = [1]
                  @jsmith.save
                  @jsmith.reload
                  assert Project.find(1).recipients.include?(@jsmith.mail)
                end
                def test_mail_notification_only_my_events
                  @jsmith.mail_notification = 'only_my_events'
                  @jsmith.notified_project_ids = []
                  @jsmith.save
                  @jsmith.reload
                  assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
                end
                def test_comments_sorting_preference
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'asc'
                  assert !@jsmith.wants_comments_in_reverse_order?
                  @jsmith.pref.comments_sorting = 'desc'
                  assert @jsmith.wants_comments_in_reverse_order?
                end
                def test_find_by_mail_should_be_case_insensitive
                  u = User.find_by_mail('JSmith@somenet.foo')
                  assert_not_nil u
                  assert_equal 'jsmith@somenet.foo', u.mail
                end
                def test_random_password
                  u = User.new
                  u.random_password
                  assert !u.password.blank?
                  assert !u.password_confirmation.blank?
                end
                context "#change_password_allowed?" do
                  should "be allowed if no auth source is set" do
                    user = User.generate_with_protected!
                    assert user.change_password_allowed?
                  end
                  should "delegate to the auth source" do
                    user = User.generate_with_protected!
                    allowed_auth_source = AuthSource.generate!
                    def allowed_auth_source.allow_password_changes?; true; end
                    denied_auth_source = AuthSource.generate!
                    def denied_auth_source.allow_password_changes?; false; end
                    assert user.change_password_allowed?
                    user.auth_source = allowed_auth_source
                    assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
                    user.auth_source = denied_auth_source
                    assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
                  end
                end
                context "#allowed_to?" do
                  context "with a unique project" do
                    should "return false if project is archived" do
                      project = Project.find(1)
                      Project.any_instance.stubs(:status).returns(Project::STATUS_ARCHIVED)
                      assert ! @admin.allowed_to?(:view_issues, Project.find(1))
                    end
                    should "return false if related module is disabled" do
                      project = Project.find(1)
                      project.enabled_module_names = ["issue_tracking"]
                      assert @admin.allowed_to?(:add_issues, project)
                      assert ! @admin.allowed_to?(:view_wiki_pages, project)
                    end
                    should "authorize nearly everything for admin users" do
                      project = Project.find(1)
                      assert ! @admin.member_of?(project)
                      %w(edit_issues delete_issues manage_news manage_documents manage_wiki).each do |p|
                        assert @admin.allowed_to?(p.to_sym, project)
                      end
                    end
                    should "authorize normal users depending on their roles" do
                      project = Project.find(1)
                      assert @jsmith.allowed_to?(:delete_messages, project)    #Manager
                      assert ! @dlopper.allowed_to?(:delete_messages, project) #Developper
                    end
                  end
                  context "with multiple projects" do
                    should "return false if array is empty" do
                      assert ! @admin.allowed_to?(:view_project, [])
                    end
                    should "return true only if user has permission on all these projects" do
                      assert @admin.allowed_to?(:view_project, Project.all)
                      assert ! @dlopper.allowed_to?(:view_project, Project.all) #cannot see Project(2)
                      assert @jsmith.allowed_to?(:edit_issues, @jsmith.projects) #Manager or Developer everywhere
                      assert ! @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects) #Dev cannot delete_issue_watchers
                    end
                    should "behave correctly with arrays of 1 project" do
                      assert ! User.anonymous.allowed_to?(:delete_issues, [Project.first])
                    end
                  end
                  context "with options[:global]" do
                    should "authorize if user has at least one role that has this permission" do
                      @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
                      @anonymous = User.find(6)
                      assert @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
                      assert ! @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
                      assert @dlopper2.allowed_to?(:add_issues, nil, :global => true)
                      assert ! @anonymous.allowed_to?(:add_issues, nil, :global => true)
                      assert @anonymous.allowed_to?(:view_issues, nil, :global => true)
                    end
                  end
                end
                context "User#notify_about?" do
                  context "Issues" do
                    setup do
                      @project = Project.find(1)
                      @author = User.generate_with_protected!
                      @assignee = User.generate_with_protected!
                      @issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author)
                    end
                    should "be true for a user with :all" do
                      @author.update_attribute(:mail_notification, 'all')
                      assert @author.notify_about?(@issue)
                    end
                    should "be false for a user with :none" do
                      @author.update_attribute(:mail_notification, 'none')
                      assert ! @author.notify_about?(@issue)
                    end
                    should "be false for a user with :only_my_events and isn't an author, creator, or assignee" do
                      @user = User.generate_with_protected!(:mail_notification => 'only_my_events')
                      Member.create!(:user => @user, :project => @project, :role_ids => [1])
                      assert ! @user.notify_about?(@issue)
                    end
                    should "be true for a user with :only_my_events and is the author" do
                      @author.update_attribute(:mail_notification, 'only_my_events')
                      assert @author.notify_about?(@issue)
                    end
                    should "be true for a user with :only_my_events and is the assignee" do
                      @assignee.update_attribute(:mail_notification, 'only_my_events')
                      assert @assignee.notify_about?(@issue)
                    end
                    should "be true for a user with :only_assigned and is the assignee" do
                      @assignee.update_attribute(:mail_notification, 'only_assigned')
                      assert @assignee.notify_about?(@issue)
                    end
                    should "be false for a user with :only_assigned and is not the assignee" do
                      @author.update_attribute(:mail_notification, 'only_assigned')
                      assert ! @author.notify_about?(@issue)
                    end
                    should "be true for a user with :only_owner and is the author" do
                      @author.update_attribute(:mail_notification, 'only_owner')
                      assert @author.notify_about?(@issue)
                    end
                    should "be false for a user with :only_owner and is not the author" do
                      @assignee.update_attribute(:mail_notification, 'only_owner')
                      assert ! @assignee.notify_about?(@issue)
                    end
                    should "be true for a user with :selected and is the author" do
                      @author.update_attribute(:mail_notification, 'selected')
                      assert @author.notify_about?(@issue)
                    end
                    should "be true for a user with :selected and is the assignee" do
                      @assignee.update_attribute(:mail_notification, 'selected')
                      assert @assignee.notify_about?(@issue)
                    end
                    should "be false for a user with :selected and is not the author or assignee" do
                      @user = User.generate_with_protected!(:mail_notification => 'selected')
                      Member.create!(:user => @user, :project => @project, :role_ids => [1])
                      assert ! @user.notify_about?(@issue)
                    end
                  end
                  context "other events" do
                    should 'be added and tested'
                  end
                end
                def test_salt_unsalted_passwords
                  # Restore a user with an unsalted password
                  user = User.find(1)
                  user.salt = nil
                  user.hashed_password = User.hash_password("unsalted")
                  user.save!
                  User.salt_unsalted_passwords!
                  user.reload
                  # Salt added
                  assert !user.salt.blank?
                  # Password still valid
                  assert user.check_password?("unsalted")
                  assert_equal user, User.try_to_login(user.login, "unsalted")
                end
                if Object.const_defined?(:OpenID)
                def test_setting_identity_url
                  normalized_open_id_url = 'http://example.com/'
                  u = User.new( :identity_url => 'http://example.com/' )
                  assert_equal normalized_open_id_url, u.identity_url
                end
                def test_setting_identity_url_without_trailing_slash
                  normalized_open_id_url = 'http://example.com/'
                  u = User.new( :identity_url => 'http://example.com' )
                  assert_equal normalized_open_id_url, u.identity_url
                end
                def test_setting_identity_url_without_protocol
                  normalized_open_id_url = 'http://example.com/'
                  u = User.new( :identity_url => 'example.com' )
                  assert_equal normalized_open_id_url, u.identity_url
                end
                def test_setting_blank_identity_url
                  u = User.new( :identity_url => 'example.com' )
                  u.identity_url = ''
                  assert u.identity_url.blank?
                end
                def test_setting_invalid_identity_url
                  u = User.new( :identity_url => 'this is not an openid url' )
                  assert u.identity_url.blank?
                end
                else
                  puts "Skipping openid tests."
                end
              end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages