kolan/Redmine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove trailing white-spaces and empty lines from unit issue test.

Browse Source 
git-svn-id: svn+ssh://rubyforge.org/var/svn/redmine/trunk@5806 e93f8b46-1217-0410-a6f0-8f06a7374b81
This commit is contained in:
Toshi MARUYAMA 2011-05-17 01:15:35 +00:00
parent 1122fd0e6a
commit de13c0007b
1 changed files with 109 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
test/unit/issue_test.rb
View File

@ -5,12 +5,12 @@
# modify it under the terms of the GNU General Public License # modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2 # as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version. # of the License, or (at your option) any later version.
# #
# This program is distributed in the hope that it will be useful, # This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of # but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details. # GNU General Public License for more details.
# #
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software # along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
@ -22,7 +22,7 @@ class IssueTest < ActiveSupport::TestCase
:trackers, :projects_trackers, :trackers, :projects_trackers,
:enabled_modules, :enabled_modules,
:versions, :versions,
:issue_statuses, :issue_categories, :issue_relations, :workflows, :issue_statuses, :issue_categories, :issue_relations, :workflows,
:enumerations, :enumerations,
:issues, :issues,
:custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values, :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
@ -34,17 +34,17 @@ class IssueTest < ActiveSupport::TestCase
issue.reload issue.reload
assert_equal 1.5, issue.estimated_hours assert_equal 1.5, issue.estimated_hours
end end
def test_create_minimal def test_create_minimal
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create')
assert issue.save assert issue.save
assert issue.description.nil? assert issue.description.nil?
end end
def test_create_with_required_custom_field def test_create_with_required_custom_field
field = IssueCustomField.find_by_name('Database') field = IssueCustomField.find_by_name('Database')
field.update_attribute(:is_required, true) field.update_attribute(:is_required, true)
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
assert issue.available_custom_fields.include?(field) assert issue.available_custom_fields.include?(field)
# No value for the custom field # No value for the custom field
@ -64,7 +64,7 @@ class IssueTest < ActiveSupport::TestCase
issue.reload issue.reload
assert_equal 'PostgreSQL', issue.custom_value_for(field).value assert_equal 'PostgreSQL', issue.custom_value_for(field).value
end end
def assert_visibility_match(user, issues) def assert_visibility_match(user, issues)
assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
end end
@ -77,17 +77,17 @@ class IssueTest < ActiveSupport::TestCase
assert_nil issues.detect {|issue| issue.is_private?} assert_nil issues.detect {|issue| issue.is_private?}
assert_visibility_match User.anonymous, issues assert_visibility_match User.anonymous, issues
end end
def test_visible_scope_for_anonymous_with_own_issues_visibility def test_visible_scope_for_anonymous_with_own_issues_visibility
Role.anonymous.update_attribute :issues_visibility, 'own' Role.anonymous.update_attribute :issues_visibility, 'own'
Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous') Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')
issues = Issue.visible(User.anonymous).all issues = Issue.visible(User.anonymous).all
assert issues.any? assert issues.any?
assert_nil issues.detect {|issue| issue.author != User.anonymous} assert_nil issues.detect {|issue| issue.author != User.anonymous}
assert_visibility_match User.anonymous, issues assert_visibility_match User.anonymous, issues
end end
def test_visible_scope_for_anonymous_without_view_issues_permissions def test_visible_scope_for_anonymous_without_view_issues_permissions
# Anonymous user should not see issues without permission # Anonymous user should not see issues without permission
Role.anonymous.remove_permission!(:view_issues) Role.anonymous.remove_permission!(:view_issues)
@ -95,7 +95,7 @@ class IssueTest < ActiveSupport::TestCase
assert issues.empty? assert issues.empty?
assert_visibility_match User.anonymous, issues assert_visibility_match User.anonymous, issues
end end
def test_visible_scope_for_non_member def test_visible_scope_for_non_member
user = User.find(9) user = User.find(9)
assert user.projects.empty? assert user.projects.empty?
@ -106,18 +106,18 @@ class IssueTest < ActiveSupport::TestCase
assert_nil issues.detect {|issue| issue.is_private?} assert_nil issues.detect {|issue| issue.is_private?}
assert_visibility_match user, issues assert_visibility_match user, issues
end end
def test_visible_scope_for_non_member_with_own_issues_visibility def test_visible_scope_for_non_member_with_own_issues_visibility
Role.non_member.update_attribute :issues_visibility, 'own' Role.non_member.update_attribute :issues_visibility, 'own'
Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member') Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
user = User.find(9) user = User.find(9)
issues = Issue.visible(user).all issues = Issue.visible(user).all
assert issues.any? assert issues.any?
assert_nil issues.detect {|issue| issue.author != user} assert_nil issues.detect {|issue| issue.author != user}
assert_visibility_match user, issues assert_visibility_match user, issues
end end
def test_visible_scope_for_non_member_without_view_issues_permissions def test_visible_scope_for_non_member_without_view_issues_permissions
# Non member user should not see issues without permission # Non member user should not see issues without permission
Role.non_member.remove_permission!(:view_issues) Role.non_member.remove_permission!(:view_issues)
@ -127,7 +127,7 @@ class IssueTest < ActiveSupport::TestCase
assert issues.empty? assert issues.empty?
assert_visibility_match user, issues assert_visibility_match user, issues
end end
def test_visible_scope_for_member def test_visible_scope_for_member
user = User.find(9) user = User.find(9)
# User should see issues of projects for which he has view_issues permissions only # User should see issues of projects for which he has view_issues permissions only
@ -139,7 +139,7 @@ class IssueTest < ActiveSupport::TestCase
assert_nil issues.detect {|issue| issue.is_private?} assert_nil issues.detect {|issue| issue.is_private?}
assert_visibility_match user, issues assert_visibility_match user, issues
end end
def test_visible_scope_for_admin def test_visible_scope_for_admin
user = User.find(1) user = User.find(1)
user.members.each(&:destroy) user.members.each(&:destroy)
@ -152,7 +152,7 @@ class IssueTest < ActiveSupport::TestCase
assert issues.detect {|issue| issue.is_private? && issue.author != user} assert issues.detect {|issue| issue.is_private? && issue.author != user}
assert_visibility_match user, issues assert_visibility_match user, issues
end end
def test_visible_scope_with_project def test_visible_scope_with_project
project = Project.find(1) project = Project.find(1)
issues = Issue.visible(User.find(2), :project => project).all issues = Issue.visible(User.find(2), :project => project).all
@ -160,7 +160,7 @@ class IssueTest < ActiveSupport::TestCase
assert_equal 1, projects.size assert_equal 1, projects.size
assert_equal project, projects.first assert_equal project, projects.first
end end
def test_visible_scope_with_project_and_subprojects def test_visible_scope_with_project_and_subprojects
project = Project.find(1) project = Project.find(1)
issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
@ -168,28 +168,28 @@ class IssueTest < ActiveSupport::TestCase
assert projects.size > 1 assert projects.size > 1
assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)} assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
end end
def test_visible_and_nested_set_scopes def test_visible_and_nested_set_scopes
assert_equal 0, Issue.find(1).descendants.visible.all.size assert_equal 0, Issue.find(1).descendants.visible.all.size
end end
def test_errors_full_messages_should_include_custom_fields_errors def test_errors_full_messages_should_include_custom_fields_errors
field = IssueCustomField.find_by_name('Database') field = IssueCustomField.find_by_name('Database')
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => 'test_create', :description => 'IssueTest#test_create_with_required_custom_field')
assert issue.available_custom_fields.include?(field) assert issue.available_custom_fields.include?(field)
# Invalid value # Invalid value
issue.custom_field_values = { field.id => 'SQLServer' } issue.custom_field_values = { field.id => 'SQLServer' }
assert !issue.valid? assert !issue.valid?
assert_equal 1, issue.errors.full_messages.size assert_equal 1, issue.errors.full_messages.size
assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first
end end
def test_update_issue_with_required_custom_field def test_update_issue_with_required_custom_field
field = IssueCustomField.find_by_name('Database') field = IssueCustomField.find_by_name('Database')
field.update_attribute(:is_required, true) field.update_attribute(:is_required, true)
issue = Issue.find(1) issue = Issue.find(1)
assert_nil issue.custom_value_for(field) assert_nil issue.custom_value_for(field)
assert issue.available_custom_fields.include?(field) assert issue.available_custom_fields.include?(field)
@ -204,23 +204,23 @@ class IssueTest < ActiveSupport::TestCase
issue.reload issue.reload
assert_equal 'PostgreSQL', issue.custom_value_for(field).value assert_equal 'PostgreSQL', issue.custom_value_for(field).value
end end
def test_should_not_update_attributes_if_custom_fields_validation_fails def test_should_not_update_attributes_if_custom_fields_validation_fails
issue = Issue.find(1) issue = Issue.find(1)
field = IssueCustomField.find_by_name('Database') field = IssueCustomField.find_by_name('Database')
assert issue.available_custom_fields.include?(field) assert issue.available_custom_fields.include?(field)
issue.custom_field_values = { field.id => 'Invalid' } issue.custom_field_values = { field.id => 'Invalid' }
issue.subject = 'Should be not be saved' issue.subject = 'Should be not be saved'
assert !issue.save assert !issue.save
issue.reload issue.reload
assert_equal "Can't print recipes", issue.subject assert_equal "Can't print recipes", issue.subject
end end
def test_should_not_recreate_custom_values_objects_on_update def test_should_not_recreate_custom_values_objects_on_update
field = IssueCustomField.find_by_name('Database') field = IssueCustomField.find_by_name('Database')
issue = Issue.find(1) issue = Issue.find(1)
issue.custom_field_values = { field.id => 'PostgreSQL' } issue.custom_field_values = { field.id => 'PostgreSQL' }
assert issue.save assert issue.save
@ -231,14 +231,14 @@ class IssueTest < ActiveSupport::TestCase
issue.reload issue.reload
assert_equal custom_value.id, issue.custom_value_for(field).id assert_equal custom_value.id, issue.custom_value_for(field).id
end end
def test_assigning_tracker_id_should_reload_custom_fields_values def test_assigning_tracker_id_should_reload_custom_fields_values
issue = Issue.new(:project => Project.find(1)) issue = Issue.new(:project => Project.find(1))
assert issue.custom_field_values.empty? assert issue.custom_field_values.empty?
issue.tracker_id = 1 issue.tracker_id = 1
assert issue.custom_field_values.any? assert issue.custom_field_values.any?
end end
def test_assigning_attributes_should_assign_tracker_id_first def test_assigning_attributes_should_assign_tracker_id_first
attributes = ActiveSupport::OrderedHash.new attributes = ActiveSupport::OrderedHash.new
attributes['custom_field_values'] = { '1' => 'MySQL' } attributes['custom_field_values'] = { '1' => 'MySQL' }
@ -248,40 +248,38 @@ class IssueTest < ActiveSupport::TestCase
assert_not_nil issue.custom_value_for(1) assert_not_nil issue.custom_value_for(1)
assert_equal 'MySQL', issue.custom_value_for(1).value assert_equal 'MySQL', issue.custom_value_for(1).value
end end
def test_should_update_issue_with_disabled_tracker def test_should_update_issue_with_disabled_tracker
p = Project.find(1) p = Project.find(1)
issue = Issue.find(1) issue = Issue.find(1)
p.trackers.delete(issue.tracker) p.trackers.delete(issue.tracker)
assert !p.trackers.include?(issue.tracker) assert !p.trackers.include?(issue.tracker)
issue.reload issue.reload
issue.subject = 'New subject' issue.subject = 'New subject'
assert issue.save assert issue.save
end end
def test_should_not_set_a_disabled_tracker def test_should_not_set_a_disabled_tracker
p = Project.find(1) p = Project.find(1)
p.trackers.delete(Tracker.find(2)) p.trackers.delete(Tracker.find(2))
issue = Issue.find(1) issue = Issue.find(1)
issue.tracker_id = 2 issue.tracker_id = 2
issue.subject = 'New subject' issue.subject = 'New subject'
assert !issue.save assert !issue.save
assert_not_nil issue.errors.on(:tracker_id) assert_not_nil issue.errors.on(:tracker_id)
end end
def test_category_based_assignment def test_category_based_assignment
issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1) issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Assignment test', :description => 'Assignment test', :category_id => 1)
assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
end end
def test_new_statuses_allowed_to def test_new_statuses_allowed_to
Workflow.delete_all Workflow.delete_all
Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false) Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)
Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false) Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)
Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true) Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)
@ -290,20 +288,20 @@ class IssueTest < ActiveSupport::TestCase
role = Role.find(1) role = Role.find(1)
tracker = Tracker.find(1) tracker = Tracker.find(1)
user = User.find(2) user = User.find(2)
issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1) issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1)
assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id) assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user) issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)
assert_equal [1, 2, 3], issue.new_statuses_allowed_to(user).map(&:id) assert_equal [1, 2, 3], issue.new_statuses_allowed_to(user).map(&:id)
issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user) issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)
assert_equal [1, 2, 4], issue.new_statuses_allowed_to(user).map(&:id) assert_equal [1, 2, 4], issue.new_statuses_allowed_to(user).map(&:id)
issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user) issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)
assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id) assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
end end
def test_copy def test_copy
issue = Issue.new.copy_from(1) issue = Issue.new.copy_from(1)
assert issue.save assert issue.save
@ -317,13 +315,13 @@ class IssueTest < ActiveSupport::TestCase
def test_copy_should_copy_status def test_copy_should_copy_status
orig = Issue.find(8) orig = Issue.find(8)
assert orig.status != IssueStatus.default assert orig.status != IssueStatus.default
issue = Issue.new.copy_from(orig) issue = Issue.new.copy_from(orig)
assert issue.save assert issue.save
issue.reload issue.reload
assert_equal orig.status, issue.status assert_equal orig.status, issue.status
end end
def test_should_close_duplicates def test_should_close_duplicates
# Create 3 issues # Create 3 issues
issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test') issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
@ -332,37 +330,37 @@ class IssueTest < ActiveSupport::TestCase
assert issue2.save assert issue2.save
issue3 = issue1.clone issue3 = issue1.clone
assert issue3.save assert issue3.save
# 2 is a dupe of 1 # 2 is a dupe of 1
IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES) IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
# And 3 is a dupe of 2 # And 3 is a dupe of 2
IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES) IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
# And 3 is a dupe of 1 (circular duplicates) # And 3 is a dupe of 1 (circular duplicates)
IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES) IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
assert issue1.reload.duplicates.include?(issue2) assert issue1.reload.duplicates.include?(issue2)
# Closing issue 1 # Closing issue 1
issue1.init_journal(User.find(:first), "Closing issue1") issue1.init_journal(User.find(:first), "Closing issue1")
issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true} issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
assert issue1.save assert issue1.save
# 2 and 3 should be also closed # 2 and 3 should be also closed
assert issue2.reload.closed? assert issue2.reload.closed?
assert issue3.reload.closed? assert issue3.reload.closed?
end end
def test_should_not_close_duplicated_issue def test_should_not_close_duplicated_issue
# Create 3 issues # Create 3 issues
issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test') issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
assert issue1.save assert issue1.save
issue2 = issue1.clone issue2 = issue1.clone
assert issue2.save assert issue2.save
# 2 is a dupe of 1 # 2 is a dupe of 1
IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES) IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
# 2 is a dup of 1 but 1 is not a duplicate of 2 # 2 is a dup of 1 but 1 is not a duplicate of 2
assert !issue2.reload.duplicates.include?(issue1) assert !issue2.reload.duplicates.include?(issue1)
# Closing issue 2 # Closing issue 2
issue2.init_journal(User.find(:first), "Closing issue2") issue2.init_journal(User.find(:first), "Closing issue2")
issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true} issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
@ -370,57 +368,57 @@ class IssueTest < ActiveSupport::TestCase
# 1 should not be also closed # 1 should not be also closed
assert !issue1.reload.closed? assert !issue1.reload.closed?
end end
def test_assignable_versions def test_assignable_versions
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
end end
def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
assert !issue.save assert !issue.save
assert_not_nil issue.errors.on(:fixed_version_id) assert_not_nil issue.errors.on(:fixed_version_id)
end end
def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')
assert !issue.save assert !issue.save
assert_not_nil issue.errors.on(:fixed_version_id) assert_not_nil issue.errors.on(:fixed_version_id)
end end
def test_should_be_able_to_assign_a_new_issue_to_an_open_version def test_should_be_able_to_assign_a_new_issue_to_an_open_version
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 3, :subject => 'New issue') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 3, :subject => 'New issue')
assert issue.save assert issue.save
end end
def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
issue = Issue.find(11) issue = Issue.find(11)
assert_equal 'closed', issue.fixed_version.status assert_equal 'closed', issue.fixed_version.status
issue.subject = 'Subject changed' issue.subject = 'Subject changed'
assert issue.save assert issue.save
end end
def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
issue = Issue.find(11) issue = Issue.find(11)
issue.status_id = 1 issue.status_id = 1
assert !issue.save assert !issue.save
assert_not_nil issue.errors.on_base assert_not_nil issue.errors.on_base
end end
def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
issue = Issue.find(11) issue = Issue.find(11)
issue.status_id = 1 issue.status_id = 1
issue.fixed_version_id = 3 issue.fixed_version_id = 3
assert issue.save assert issue.save
end end
def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
issue = Issue.find(12) issue = Issue.find(12)
assert_equal 'locked', issue.fixed_version.status assert_equal 'locked', issue.fixed_version.status
issue.status_id = 1 issue.status_id = 1
assert issue.save assert issue.save
end end
def test_move_to_another_project_with_same_category def test_move_to_another_project_with_same_category
issue = Issue.find(1) issue = Issue.find(1)
assert issue.move_to_project(Project.find(2)) assert issue.move_to_project(Project.find(2))
@ -431,7 +429,7 @@ class IssueTest < ActiveSupport::TestCase
# Make sure time entries were move to the target project # Make sure time entries were move to the target project
assert_equal 2, issue.time_entries.first.project_id assert_equal 2, issue.time_entries.first.project_id
end end
def test_move_to_another_project_without_same_category def test_move_to_another_project_without_same_category
issue = Issue.find(2) issue = Issue.find(2)
assert issue.move_to_project(Project.find(2)) assert issue.move_to_project(Project.find(2))
@ -440,7 +438,7 @@ class IssueTest < ActiveSupport::TestCase
# Category cleared # Category cleared
assert_nil issue.category_id assert_nil issue.category_id
end end
def test_move_to_another_project_should_clear_fixed_version_when_not_shared def test_move_to_another_project_should_clear_fixed_version_when_not_shared
issue = Issue.find(1) issue = Issue.find(1)
issue.update_attribute(:fixed_version_id, 1) issue.update_attribute(:fixed_version_id, 1)
@ -450,7 +448,7 @@ class IssueTest < ActiveSupport::TestCase
# Cleared fixed_version # Cleared fixed_version
assert_equal nil, issue.fixed_version assert_equal nil, issue.fixed_version
end end
def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
issue = Issue.find(1) issue = Issue.find(1)
issue.update_attribute(:fixed_version_id, 4) issue.update_attribute(:fixed_version_id, 4)
@ -460,7 +458,7 @@ class IssueTest < ActiveSupport::TestCase
# Keep fixed_version # Keep fixed_version
assert_equal 4, issue.fixed_version_id assert_equal 4, issue.fixed_version_id
end end
def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
issue = Issue.find(1) issue = Issue.find(1)
issue.update_attribute(:fixed_version_id, 1) issue.update_attribute(:fixed_version_id, 1)
@ -470,7 +468,7 @@ class IssueTest < ActiveSupport::TestCase
# Cleared fixed_version # Cleared fixed_version
assert_equal nil, issue.fixed_version assert_equal nil, issue.fixed_version
end end
def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
issue = Issue.find(1) issue = Issue.find(1)
issue.update_attribute(:fixed_version_id, 7) issue.update_attribute(:fixed_version_id, 7)
@ -480,7 +478,7 @@ class IssueTest < ActiveSupport::TestCase
# Keep fixed_version # Keep fixed_version
assert_equal 7, issue.fixed_version_id assert_equal 7, issue.fixed_version_id
end end
def test_move_to_another_project_with_disabled_tracker def test_move_to_another_project_with_disabled_tracker
issue = Issue.find(1) issue = Issue.find(1)
target = Project.find(2) target = Project.find(2)
@ -490,7 +488,7 @@ class IssueTest < ActiveSupport::TestCase
issue.reload issue.reload
assert_equal 1, issue.project_id assert_equal 1, issue.project_id
end end
def test_copy_to_the_same_project def test_copy_to_the_same_project
issue = Issue.find(1) issue = Issue.find(1)
copy = nil copy = nil
@ -501,7 +499,7 @@ class IssueTest < ActiveSupport::TestCase
assert_equal issue.project, copy.project assert_equal issue.project, copy.project
assert_equal "125", copy.custom_value_for(2).value assert_equal "125", copy.custom_value_for(2).value
end end
def test_copy_to_another_project_and_tracker def test_copy_to_another_project_and_tracker
issue = Issue.find(1) issue = Issue.find(1)
copy = nil copy = nil
@ -522,7 +520,7 @@ class IssueTest < ActiveSupport::TestCase
@issue = Issue.find(1) @issue = Issue.find(1)
@copy = nil @copy = nil
end end
should "not create a journal" do should "not create a journal" do
@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}}) @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
assert_equal 0, @copy.reload.journals.size assert_equal 0, @copy.reload.journals.size
@ -550,14 +548,14 @@ class IssueTest < ActiveSupport::TestCase
assert_equal date, @copy.due_date assert_equal date, @copy.due_date
end end
should "set current user as author" do should "set current user as author" do
User.current = User.find(9) User.current = User.find(9)
@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}}) @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}})
assert_equal User.current, @copy.author assert_equal User.current, @copy.author
end end
should "keep journal notes" do should "keep journal notes" do
date = Date.today date = Date.today
notes = "Notes added when copying" notes = "Notes added when copying"
@ -572,7 +570,7 @@ class IssueTest < ActiveSupport::TestCase
end end
end end
end end
def test_recipients_should_not_include_users_that_cannot_view_the_issue def test_recipients_should_not_include_users_that_cannot_view_the_issue
issue = Issue.find(12) issue = Issue.find(12)
assert issue.recipients.include?(issue.author.mail) assert issue.recipients.include?(issue.author.mail)
@ -589,50 +587,50 @@ class IssueTest < ActiveSupport::TestCase
assert issue.watched_by?(user) assert issue.watched_by?(user)
assert !issue.watcher_recipients.include?(user.mail) assert !issue.watcher_recipients.include?(user.mail)
end end
def test_issue_destroy def test_issue_destroy
Issue.find(1).destroy Issue.find(1).destroy
assert_nil Issue.find_by_id(1) assert_nil Issue.find_by_id(1)
assert_nil TimeEntry.find_by_issue_id(1) assert_nil TimeEntry.find_by_issue_id(1)
end end
def test_blocked def test_blocked
blocked_issue = Issue.find(9) blocked_issue = Issue.find(9)
blocking_issue = Issue.find(10) blocking_issue = Issue.find(10)
assert blocked_issue.blocked? assert blocked_issue.blocked?
assert !blocking_issue.blocked? assert !blocking_issue.blocked?
end end
def test_blocked_issues_dont_allow_closed_statuses def test_blocked_issues_dont_allow_closed_statuses
blocked_issue = Issue.find(9) blocked_issue = Issue.find(9)
allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002)) allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
assert !allowed_statuses.empty? assert !allowed_statuses.empty?
closed_statuses = allowed_statuses.select {|st| st.is_closed?} closed_statuses = allowed_statuses.select {|st| st.is_closed?}
assert closed_statuses.empty? assert closed_statuses.empty?
end end
def test_unblocked_issues_allow_closed_statuses def test_unblocked_issues_allow_closed_statuses
blocking_issue = Issue.find(10) blocking_issue = Issue.find(10)
allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002)) allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
assert !allowed_statuses.empty? assert !allowed_statuses.empty?
closed_statuses = allowed_statuses.select {|st| st.is_closed?} closed_statuses = allowed_statuses.select {|st| st.is_closed?}
assert !closed_statuses.empty? assert !closed_statuses.empty?
end end
def test_rescheduling_an_issue_should_reschedule_following_issue def test_rescheduling_an_issue_should_reschedule_following_issue
issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2) issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2)
issue2 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2) issue2 = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :subject => '-', :start_date => Date.today, :due_date => Date.today + 2)
IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES) IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
assert_equal issue1.due_date + 1, issue2.reload.start_date assert_equal issue1.due_date + 1, issue2.reload.start_date
issue1.due_date = Date.today + 5 issue1.due_date = Date.today + 5
issue1.save! issue1.save!
assert_equal issue1.due_date + 1, issue2.reload.start_date assert_equal issue1.due_date + 1, issue2.reload.start_date
end end
def test_overdue def test_overdue
assert Issue.new(:due_date => 1.day.ago.to_date).overdue? assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
assert !Issue.new(:due_date => Date.today).overdue? assert !Issue.new(:due_date => Date.today).overdue?
@ -679,13 +677,13 @@ class IssueTest < ActiveSupport::TestCase
should "not show the issue author twice" do should "not show the issue author twice" do
assignable_user_ids = Issue.find(1).assignable_users.collect(&:id) assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
assert_equal 2, assignable_user_ids.length assert_equal 2, assignable_user_ids.length
assignable_user_ids.each do |user_id| assignable_user_ids.each do |user_id|
assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once" assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once"
end end
end end
end end
def test_create_should_send_email_notification def test_create_should_send_email_notification
ActionMailer::Base.deliveries.clear ActionMailer::Base.deliveries.clear
issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create', :estimated_hours => '1:30') issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create', :estimated_hours => '1:30')
@ -698,13 +696,13 @@ class IssueTest < ActiveSupport::TestCase
ActionMailer::Base.deliveries.clear ActionMailer::Base.deliveries.clear
issue = Issue.find(1) issue = Issue.find(1)
stale = Issue.find(1) stale = Issue.find(1)
issue.init_journal(User.find(1)) issue.init_journal(User.find(1))
issue.subject = 'Subjet update' issue.subject = 'Subjet update'
assert issue.save assert issue.save
assert_equal 1, ActionMailer::Base.deliveries.size assert_equal 1, ActionMailer::Base.deliveries.size
ActionMailer::Base.deliveries.clear ActionMailer::Base.deliveries.clear
stale.init_journal(User.find(1)) stale.init_journal(User.find(1))
stale.subject = 'Another subjet update' stale.subject = 'Another subjet update'
assert_raise ActiveRecord::StaleObjectError do assert_raise ActiveRecord::StaleObjectError do
@ -712,14 +710,14 @@ class IssueTest < ActiveSupport::TestCase
end end
assert ActionMailer::Base.deliveries.empty? assert ActionMailer::Base.deliveries.empty?
end end
def test_journalized_description def test_journalized_description
IssueCustomField.delete_all IssueCustomField.delete_all
i = Issue.first i = Issue.first
old_description = i.description old_description = i.description
new_description = "This is the new description" new_description = "This is the new description"
i.init_journal(User.find(2)) i.init_journal(User.find(2))
i.description = new_description i.description = new_description
assert_difference 'Journal.count', 1 do assert_difference 'Journal.count', 1 do
@ -727,7 +725,7 @@ class IssueTest < ActiveSupport::TestCase
i.save! i.save!
end end
end end
detail = JournalDetail.first(:order => 'id DESC') detail = JournalDetail.first(:order => 'id DESC')
assert_equal i, detail.journal.journalized assert_equal i, detail.journal.journalized
assert_equal 'attr', detail.property assert_equal 'attr', detail.property
@ -735,7 +733,7 @@ class IssueTest < ActiveSupport::TestCase
assert_equal old_description, detail.old_value assert_equal old_description, detail.old_value
assert_equal new_description, detail.value assert_equal new_description, detail.value
end end
def test_saving_twice_should_not_duplicate_journal_details def test_saving_twice_should_not_duplicate_journal_details
i = Issue.find(:first) i = Issue.find(:first)
i.init_journal(User.find(2), 'Some notes') i.init_journal(User.find(2), 'Some notes')
@ -765,7 +763,7 @@ class IssueTest < ActiveSupport::TestCase
assert IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_PRECEDES) assert IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_PRECEDES)
assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES) assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)
assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_PRECEDES) assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_PRECEDES)
assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
end end
@ -775,7 +773,7 @@ class IssueTest < ActiveSupport::TestCase
assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES) assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)
# Validation skipping # Validation skipping
assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false) assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false)
assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
end end
@ -787,10 +785,10 @@ class IssueTest < ActiveSupport::TestCase
# Validation skipping # Validation skipping
assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false) assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false)
assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false) assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false)
assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
end end
context "#done_ratio" do context "#done_ratio" do
setup do setup do
@issue = Issue.find(1) @issue = Issue.find(1)
@ -800,12 +798,12 @@ class IssueTest < ActiveSupport::TestCase
@issue_status2 = IssueStatus.find(2) @issue_status2 = IssueStatus.find(2)
@issue_status2.update_attribute(:default_done_ratio, 0) @issue_status2.update_attribute(:default_done_ratio, 0)
end end
context "with Setting.issue_done_ratio using the issue_field" do context "with Setting.issue_done_ratio using the issue_field" do
setup do setup do
Setting.issue_done_ratio = 'issue_field' Setting.issue_done_ratio = 'issue_field'
end end
should "read the issue's field" do should "read the issue's field" do
assert_equal 0, @issue.done_ratio assert_equal 0, @issue.done_ratio
assert_equal 30, @issue2.done_ratio assert_equal 30, @issue2.done_ratio
@ -816,7 +814,7 @@ class IssueTest < ActiveSupport::TestCase
setup do setup do
Setting.issue_done_ratio = 'issue_status' Setting.issue_done_ratio = 'issue_status'
end end
should "read the Issue Status's default done ratio" do should "read the Issue Status's default done ratio" do
assert_equal 50, @issue.done_ratio assert_equal 50, @issue.done_ratio
assert_equal 0, @issue2.done_ratio assert_equal 0, @issue2.done_ratio
@ -833,12 +831,12 @@ class IssueTest < ActiveSupport::TestCase
@issue_status2 = IssueStatus.find(2) @issue_status2 = IssueStatus.find(2)
@issue_status2.update_attribute(:default_done_ratio, 0) @issue_status2.update_attribute(:default_done_ratio, 0)
end end
context "with Setting.issue_done_ratio using the issue_field" do context "with Setting.issue_done_ratio using the issue_field" do
setup do setup do
Setting.issue_done_ratio = 'issue_field' Setting.issue_done_ratio = 'issue_field'
end end
should "not change the issue" do should "not change the issue" do
@issue.update_done_ratio_from_issue_status @issue.update_done_ratio_from_issue_status
@issue2.update_done_ratio_from_issue_status @issue2.update_done_ratio_from_issue_status
@ -852,7 +850,7 @@ class IssueTest < ActiveSupport::TestCase
setup do setup do
Setting.issue_done_ratio = 'issue_status' Setting.issue_done_ratio = 'issue_status'
end end
should "change the issue's done ratio" do should "change the issue's done ratio" do
@issue.update_done_ratio_from_issue_status @issue.update_done_ratio_from_issue_status
@issue2.update_done_ratio_from_issue_status @issue2.update_done_ratio_from_issue_status
@ -912,19 +910,18 @@ class IssueTest < ActiveSupport::TestCase
assert_equal 1, groups.size assert_equal 1, groups.size
assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i} assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
end end
context ".allowed_target_projects_on_move" do context ".allowed_target_projects_on_move" do
should "return all active projects for admin users" do should "return all active projects for admin users" do
User.current = User.find(1) User.current = User.find(1)
assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
end end
should "return allowed projects for non admin users" do should "return allowed projects for non admin users" do
User.current = User.find(2) User.current = User.find(2)
Role.non_member.remove_permission! :move_issues Role.non_member.remove_permission! :move_issues
assert_equal 3, Issue.allowed_target_projects_on_move.size assert_equal 3, Issue.allowed_target_projects_on_move.size
Role.non_member.add_permission! :move_issues Role.non_member.add_permission! :move_issues
assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
end end
@ -938,7 +935,7 @@ class IssueTest < ActiveSupport::TestCase
def test_on_active_projects_scope def test_on_active_projects_scope
assert Project.find(2).archive assert Project.find(2).archive
before = Issue.on_active_project.length before = Issue.on_active_project.length
# test inclusion to results # test inclusion to results
issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first) issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first)
@ -957,7 +954,7 @@ class IssueTest < ActiveSupport::TestCase
@assignee = User.generate_with_protected! @assignee = User.generate_with_protected!
@issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author) @issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author)
end end
should "include project recipients" do should "include project recipients" do
assert @project.recipients.present? assert @project.recipients.present?
@project.recipients.each do |project_recipient| @project.recipients.each do |project_recipient|
@ -969,7 +966,7 @@ class IssueTest < ActiveSupport::TestCase
assert @issue.author, "No author set for Issue" assert @issue.author, "No author set for Issue"
assert @issue.recipients.include?(@issue.author.mail) assert @issue.recipients.include?(@issue.author.mail)
end end
should "include the assigned to user if the assigned to user is active" do should "include the assigned to user if the assigned to user is active" do
assert @issue.assigned_to, "No assigned_to set for Issue" assert @issue.assigned_to, "No assigned_to set for Issue"
assert @issue.recipients.include?(@issue.assigned_to.mail) assert @issue.recipients.include?(@issue.assigned_to.mail)