##// END OF EJS Templates
jro_apps » redmine
RSS
Do not mass create API keys for existing users....
Do not mass create API keys for existing users. They will be created on the fly if needed, just like for new users. git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@3221 e93f8b46-1217-0410-a6f0-8f06a7374b81
Eric Davis - - Load All Authors

File last commit:

r3051:4fb554e95d69
r3107:edab0f0cbb85
Show More
project_test.rb
730 lines | 26.2 KiB | text/x-ruby | RubyLexer
/ test / unit / project_test.rb
History | Annotation | Raw |Copy content |Copy permalink
# redMine - project management software
# Copyright (C) 2006-2007 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.dirname(__FILE__) + '/../test_helper'
class ProjectTest < ActiveSupport::TestCase
fixtures :all
def setup
@ecookbook = Project.find(1)
@ecookbook_sub1 = Project.find(3)
User.current = nil
end
should_validate_presence_of :name
should_validate_presence_of :identifier
should_validate_uniqueness_of :name
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_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,
"12" => false,
"new" => false}
to_test.each do |identifier, valid|
p = Project.new
p.identifier = identifier
p.valid?
assert_equal valid, p.errors.on('identifier').nil?
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 !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 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 Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).empty?
assert Board.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).empty?
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.sort_by(&:name), parent.children
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.sort_by(&:name), parent.children
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.empty?
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
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_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_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
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_id => 5,
: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 members" do
assert @project.valid?
assert @project.members.empty?
assert @project.copy(@source_project)
assert_equal @source_project.members.size, @project.members.size
@project.members.each do |member|
assert member
assert_equal @project, member.project
end
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
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" do
assert @project.copy(@source_project)
assert @project.wiki
assert_equal 1, @project.wiki.pages.length
@project.wiki.pages.each do |wiki_page|
assert wiki_page.content
assert !@source_project.wiki.pages.include?(wiki_page)
end
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
end