##// END OF EJS Templates
jro_apps » redmine
RSS
code layout clean up of test_errors_full_messages_should_include_custom_fields_errors at test/unit/issue_test.rb...
Toshi MARUYAMA -
r7485:925e11ed16ac
parent child
Show More
Side by Side Unified
Context file:
r7485:925e11ed16ac Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1108 +1,1109
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2011 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 require File.expand_path('../../test_helper', __FILE__)
19 19
20 20 class IssueTest < ActiveSupport::TestCase
21 21 fixtures :projects, :users, :members, :member_roles, :roles,
22 22 :trackers, :projects_trackers,
23 23 :enabled_modules,
24 24 :versions,
25 25 :issue_statuses, :issue_categories, :issue_relations, :workflows,
26 26 :enumerations,
27 27 :issues,
28 28 :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
29 29 :time_entries
30 30
31 31 def test_create
32 32 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
33 33 :status_id => 1, :priority => IssuePriority.all.first,
34 34 :subject => 'test_create',
35 35 :description => 'IssueTest#test_create', :estimated_hours => '1:30')
36 36 assert issue.save
37 37 issue.reload
38 38 assert_equal 1.5, issue.estimated_hours
39 39 end
40 40
41 41 def test_create_minimal
42 42 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
43 43 :status_id => 1, :priority => IssuePriority.all.first,
44 44 :subject => 'test_create')
45 45 assert issue.save
46 46 assert issue.description.nil?
47 47 end
48 48
49 49 def test_create_with_required_custom_field
50 50 field = IssueCustomField.find_by_name('Database')
51 51 field.update_attribute(:is_required, true)
52 52
53 53 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
54 54 :status_id => 1, :subject => 'test_create',
55 55 :description => 'IssueTest#test_create_with_required_custom_field')
56 56 assert issue.available_custom_fields.include?(field)
57 57 # No value for the custom field
58 58 assert !issue.save
59 59 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
60 60 # Blank value
61 61 issue.custom_field_values = { field.id => '' }
62 62 assert !issue.save
63 63 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
64 64 # Invalid value
65 65 issue.custom_field_values = { field.id => 'SQLServer' }
66 66 assert !issue.save
67 67 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
68 68 # Valid value
69 69 issue.custom_field_values = { field.id => 'PostgreSQL' }
70 70 assert issue.save
71 71 issue.reload
72 72 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
73 73 end
74 74
75 75 def test_create_with_group_assignment
76 76 with_settings :issue_group_assignment => '1' do
77 77 assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
78 78 :subject => 'Group assignment',
79 79 :assigned_to_id => 11).save
80 80 issue = Issue.first(:order => 'id DESC')
81 81 assert_kind_of Group, issue.assigned_to
82 82 assert_equal Group.find(11), issue.assigned_to
83 83 end
84 84 end
85 85
86 86 def assert_visibility_match(user, issues)
87 87 assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
88 88 end
89 89
90 90 def test_visible_scope_for_anonymous
91 91 # Anonymous user should see issues of public projects only
92 92 issues = Issue.visible(User.anonymous).all
93 93 assert issues.any?
94 94 assert_nil issues.detect {|issue| !issue.project.is_public?}
95 95 assert_nil issues.detect {|issue| issue.is_private?}
96 96 assert_visibility_match User.anonymous, issues
97 97 end
98 98
99 99 def test_visible_scope_for_anonymous_with_own_issues_visibility
100 100 Role.anonymous.update_attribute :issues_visibility, 'own'
101 101 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')
102 102
103 103 issues = Issue.visible(User.anonymous).all
104 104 assert issues.any?
105 105 assert_nil issues.detect {|issue| issue.author != User.anonymous}
106 106 assert_visibility_match User.anonymous, issues
107 107 end
108 108
109 109 def test_visible_scope_for_anonymous_without_view_issues_permissions
110 110 # Anonymous user should not see issues without permission
111 111 Role.anonymous.remove_permission!(:view_issues)
112 112 issues = Issue.visible(User.anonymous).all
113 113 assert issues.empty?
114 114 assert_visibility_match User.anonymous, issues
115 115 end
116 116
117 117 def test_visible_scope_for_non_member
118 118 user = User.find(9)
119 119 assert user.projects.empty?
120 120 # Non member user should see issues of public projects only
121 121 issues = Issue.visible(user).all
122 122 assert issues.any?
123 123 assert_nil issues.detect {|issue| !issue.project.is_public?}
124 124 assert_nil issues.detect {|issue| issue.is_private?}
125 125 assert_visibility_match user, issues
126 126 end
127 127
128 128 def test_visible_scope_for_non_member_with_own_issues_visibility
129 129 Role.non_member.update_attribute :issues_visibility, 'own'
130 130 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
131 131 user = User.find(9)
132 132
133 133 issues = Issue.visible(user).all
134 134 assert issues.any?
135 135 assert_nil issues.detect {|issue| issue.author != user}
136 136 assert_visibility_match user, issues
137 137 end
138 138
139 139 def test_visible_scope_for_non_member_without_view_issues_permissions
140 140 # Non member user should not see issues without permission
141 141 Role.non_member.remove_permission!(:view_issues)
142 142 user = User.find(9)
143 143 assert user.projects.empty?
144 144 issues = Issue.visible(user).all
145 145 assert issues.empty?
146 146 assert_visibility_match user, issues
147 147 end
148 148
149 149 def test_visible_scope_for_member
150 150 user = User.find(9)
151 151 # User should see issues of projects for which he has view_issues permissions only
152 152 Role.non_member.remove_permission!(:view_issues)
153 153 Member.create!(:principal => user, :project_id => 3, :role_ids => [2])
154 154 issues = Issue.visible(user).all
155 155 assert issues.any?
156 156 assert_nil issues.detect {|issue| issue.project_id != 3}
157 157 assert_nil issues.detect {|issue| issue.is_private?}
158 158 assert_visibility_match user, issues
159 159 end
160 160
161 161 def test_visible_scope_for_admin
162 162 user = User.find(1)
163 163 user.members.each(&:destroy)
164 164 assert user.projects.empty?
165 165 issues = Issue.visible(user).all
166 166 assert issues.any?
167 167 # Admin should see issues on private projects that he does not belong to
168 168 assert issues.detect {|issue| !issue.project.is_public?}
169 169 # Admin should see private issues of other users
170 170 assert issues.detect {|issue| issue.is_private? && issue.author != user}
171 171 assert_visibility_match user, issues
172 172 end
173 173
174 174 def test_visible_scope_with_project
175 175 project = Project.find(1)
176 176 issues = Issue.visible(User.find(2), :project => project).all
177 177 projects = issues.collect(&:project).uniq
178 178 assert_equal 1, projects.size
179 179 assert_equal project, projects.first
180 180 end
181 181
182 182 def test_visible_scope_with_project_and_subprojects
183 183 project = Project.find(1)
184 184 issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
185 185 projects = issues.collect(&:project).uniq
186 186 assert projects.size > 1
187 187 assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
188 188 end
189 189
190 190 def test_visible_and_nested_set_scopes
191 191 assert_equal 0, Issue.find(1).descendants.visible.all.size
192 192 end
193 193
194 194 def test_errors_full_messages_should_include_custom_fields_errors
195 195 field = IssueCustomField.find_by_name('Database')
196 196
197 197 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
198 198 :status_id => 1, :subject => 'test_create',
199 199 :description => 'IssueTest#test_create_with_required_custom_field')
200 200 assert issue.available_custom_fields.include?(field)
201 201 # Invalid value
202 202 issue.custom_field_values = { field.id => 'SQLServer' }
203 203
204 204 assert !issue.valid?
205 205 assert_equal 1, issue.errors.full_messages.size
206 assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}", issue.errors.full_messages.first
206 assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",
207 issue.errors.full_messages.first
207 208 end
208 209
209 210 def test_update_issue_with_required_custom_field
210 211 field = IssueCustomField.find_by_name('Database')
211 212 field.update_attribute(:is_required, true)
212 213
213 214 issue = Issue.find(1)
214 215 assert_nil issue.custom_value_for(field)
215 216 assert issue.available_custom_fields.include?(field)
216 217 # No change to custom values, issue can be saved
217 218 assert issue.save
218 219 # Blank value
219 220 issue.custom_field_values = { field.id => '' }
220 221 assert !issue.save
221 222 # Valid value
222 223 issue.custom_field_values = { field.id => 'PostgreSQL' }
223 224 assert issue.save
224 225 issue.reload
225 226 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
226 227 end
227 228
228 229 def test_should_not_update_attributes_if_custom_fields_validation_fails
229 230 issue = Issue.find(1)
230 231 field = IssueCustomField.find_by_name('Database')
231 232 assert issue.available_custom_fields.include?(field)
232 233
233 234 issue.custom_field_values = { field.id => 'Invalid' }
234 235 issue.subject = 'Should be not be saved'
235 236 assert !issue.save
236 237
237 238 issue.reload
238 239 assert_equal "Can't print recipes", issue.subject
239 240 end
240 241
241 242 def test_should_not_recreate_custom_values_objects_on_update
242 243 field = IssueCustomField.find_by_name('Database')
243 244
244 245 issue = Issue.find(1)
245 246 issue.custom_field_values = { field.id => 'PostgreSQL' }
246 247 assert issue.save
247 248 custom_value = issue.custom_value_for(field)
248 249 issue.reload
249 250 issue.custom_field_values = { field.id => 'MySQL' }
250 251 assert issue.save
251 252 issue.reload
252 253 assert_equal custom_value.id, issue.custom_value_for(field).id
253 254 end
254 255
255 256 def test_assigning_tracker_id_should_reload_custom_fields_values
256 257 issue = Issue.new(:project => Project.find(1))
257 258 assert issue.custom_field_values.empty?
258 259 issue.tracker_id = 1
259 260 assert issue.custom_field_values.any?
260 261 end
261 262
262 263 def test_assigning_attributes_should_assign_tracker_id_first
263 264 attributes = ActiveSupport::OrderedHash.new
264 265 attributes['custom_field_values'] = { '1' => 'MySQL' }
265 266 attributes['tracker_id'] = '1'
266 267 issue = Issue.new(:project => Project.find(1))
267 268 issue.attributes = attributes
268 269 assert_not_nil issue.custom_value_for(1)
269 270 assert_equal 'MySQL', issue.custom_value_for(1).value
270 271 end
271 272
272 273 def test_should_update_issue_with_disabled_tracker
273 274 p = Project.find(1)
274 275 issue = Issue.find(1)
275 276
276 277 p.trackers.delete(issue.tracker)
277 278 assert !p.trackers.include?(issue.tracker)
278 279
279 280 issue.reload
280 281 issue.subject = 'New subject'
281 282 assert issue.save
282 283 end
283 284
284 285 def test_should_not_set_a_disabled_tracker
285 286 p = Project.find(1)
286 287 p.trackers.delete(Tracker.find(2))
287 288
288 289 issue = Issue.find(1)
289 290 issue.tracker_id = 2
290 291 issue.subject = 'New subject'
291 292 assert !issue.save
292 293 assert_not_nil issue.errors[:tracker_id]
293 294 end
294 295
295 296 def test_category_based_assignment
296 297 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
297 298 :status_id => 1, :priority => IssuePriority.all.first,
298 299 :subject => 'Assignment test',
299 300 :description => 'Assignment test', :category_id => 1)
300 301 assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
301 302 end
302 303
303 304 def test_new_statuses_allowed_to
304 305 Workflow.delete_all
305 306
306 307 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)
307 308 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)
308 309 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)
309 310 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 5, :author => true, :assignee => true)
310 311 status = IssueStatus.find(1)
311 312 role = Role.find(1)
312 313 tracker = Tracker.find(1)
313 314 user = User.find(2)
314 315
315 316 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1)
316 317 assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
317 318
318 319 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)
319 320 assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
320 321
321 322 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)
322 323 assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
323 324
324 325 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)
325 326 assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
326 327 end
327 328
328 329 def test_copy
329 330 issue = Issue.new.copy_from(1)
330 331 assert issue.save
331 332 issue.reload
332 333 orig = Issue.find(1)
333 334 assert_equal orig.subject, issue.subject
334 335 assert_equal orig.tracker, issue.tracker
335 336 assert_equal "125", issue.custom_value_for(2).value
336 337 end
337 338
338 339 def test_copy_should_copy_status
339 340 orig = Issue.find(8)
340 341 assert orig.status != IssueStatus.default
341 342
342 343 issue = Issue.new.copy_from(orig)
343 344 assert issue.save
344 345 issue.reload
345 346 assert_equal orig.status, issue.status
346 347 end
347 348
348 349 def test_should_close_duplicates
349 350 # Create 3 issues
350 351 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
351 352 :status_id => 1, :priority => IssuePriority.all.first,
352 353 :subject => 'Duplicates test', :description => 'Duplicates test')
353 354 assert issue1.save
354 355 issue2 = issue1.clone
355 356 assert issue2.save
356 357 issue3 = issue1.clone
357 358 assert issue3.save
358 359
359 360 # 2 is a dupe of 1
360 361 IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
361 362 # And 3 is a dupe of 2
362 363 IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
363 364 # And 3 is a dupe of 1 (circular duplicates)
364 365 IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
365 366
366 367 assert issue1.reload.duplicates.include?(issue2)
367 368
368 369 # Closing issue 1
369 370 issue1.init_journal(User.find(:first), "Closing issue1")
370 371 issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
371 372 assert issue1.save
372 373 # 2 and 3 should be also closed
373 374 assert issue2.reload.closed?
374 375 assert issue3.reload.closed?
375 376 end
376 377
377 378 def test_should_not_close_duplicated_issue
378 379 # Create 3 issues
379 380 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
380 381 :status_id => 1, :priority => IssuePriority.all.first,
381 382 :subject => 'Duplicates test', :description => 'Duplicates test')
382 383 assert issue1.save
383 384 issue2 = issue1.clone
384 385 assert issue2.save
385 386
386 387 # 2 is a dupe of 1
387 388 IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
388 389 # 2 is a dup of 1 but 1 is not a duplicate of 2
389 390 assert !issue2.reload.duplicates.include?(issue1)
390 391
391 392 # Closing issue 2
392 393 issue2.init_journal(User.find(:first), "Closing issue2")
393 394 issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
394 395 assert issue2.save
395 396 # 1 should not be also closed
396 397 assert !issue1.reload.closed?
397 398 end
398 399
399 400 def test_assignable_versions
400 401 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
401 402 assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
402 403 end
403 404
404 405 def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
405 406 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
406 407 assert !issue.save
407 408 assert_not_nil issue.errors.on(:fixed_version_id)
408 409 end
409 410
410 411 def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
411 412 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')
412 413 assert !issue.save
413 414 assert_not_nil issue.errors.on(:fixed_version_id)
414 415 end
415 416
416 417 def test_should_be_able_to_assign_a_new_issue_to_an_open_version
417 418 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 3, :subject => 'New issue')
418 419 assert issue.save
419 420 end
420 421
421 422 def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
422 423 issue = Issue.find(11)
423 424 assert_equal 'closed', issue.fixed_version.status
424 425 issue.subject = 'Subject changed'
425 426 assert issue.save
426 427 end
427 428
428 429 def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
429 430 issue = Issue.find(11)
430 431 issue.status_id = 1
431 432 assert !issue.save
432 433 assert_not_nil issue.errors.on_base
433 434 end
434 435
435 436 def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
436 437 issue = Issue.find(11)
437 438 issue.status_id = 1
438 439 issue.fixed_version_id = 3
439 440 assert issue.save
440 441 end
441 442
442 443 def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
443 444 issue = Issue.find(12)
444 445 assert_equal 'locked', issue.fixed_version.status
445 446 issue.status_id = 1
446 447 assert issue.save
447 448 end
448 449
449 450 def test_move_to_another_project_with_same_category
450 451 issue = Issue.find(1)
451 452 assert issue.move_to_project(Project.find(2))
452 453 issue.reload
453 454 assert_equal 2, issue.project_id
454 455 # Category changes
455 456 assert_equal 4, issue.category_id
456 457 # Make sure time entries were move to the target project
457 458 assert_equal 2, issue.time_entries.first.project_id
458 459 end
459 460
460 461 def test_move_to_another_project_without_same_category
461 462 issue = Issue.find(2)
462 463 assert issue.move_to_project(Project.find(2))
463 464 issue.reload
464 465 assert_equal 2, issue.project_id
465 466 # Category cleared
466 467 assert_nil issue.category_id
467 468 end
468 469
469 470 def test_move_to_another_project_should_clear_fixed_version_when_not_shared
470 471 issue = Issue.find(1)
471 472 issue.update_attribute(:fixed_version_id, 1)
472 473 assert issue.move_to_project(Project.find(2))
473 474 issue.reload
474 475 assert_equal 2, issue.project_id
475 476 # Cleared fixed_version
476 477 assert_equal nil, issue.fixed_version
477 478 end
478 479
479 480 def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
480 481 issue = Issue.find(1)
481 482 issue.update_attribute(:fixed_version_id, 4)
482 483 assert issue.move_to_project(Project.find(5))
483 484 issue.reload
484 485 assert_equal 5, issue.project_id
485 486 # Keep fixed_version
486 487 assert_equal 4, issue.fixed_version_id
487 488 end
488 489
489 490 def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
490 491 issue = Issue.find(1)
491 492 issue.update_attribute(:fixed_version_id, 1)
492 493 assert issue.move_to_project(Project.find(5))
493 494 issue.reload
494 495 assert_equal 5, issue.project_id
495 496 # Cleared fixed_version
496 497 assert_equal nil, issue.fixed_version
497 498 end
498 499
499 500 def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
500 501 issue = Issue.find(1)
501 502 issue.update_attribute(:fixed_version_id, 7)
502 503 assert issue.move_to_project(Project.find(2))
503 504 issue.reload
504 505 assert_equal 2, issue.project_id
505 506 # Keep fixed_version
506 507 assert_equal 7, issue.fixed_version_id
507 508 end
508 509
509 510 def test_move_to_another_project_with_disabled_tracker
510 511 issue = Issue.find(1)
511 512 target = Project.find(2)
512 513 target.tracker_ids = [3]
513 514 target.save
514 515 assert_equal false, issue.move_to_project(target)
515 516 issue.reload
516 517 assert_equal 1, issue.project_id
517 518 end
518 519
519 520 def test_copy_to_the_same_project
520 521 issue = Issue.find(1)
521 522 copy = nil
522 523 assert_difference 'Issue.count' do
523 524 copy = issue.move_to_project(issue.project, nil, :copy => true)
524 525 end
525 526 assert_kind_of Issue, copy
526 527 assert_equal issue.project, copy.project
527 528 assert_equal "125", copy.custom_value_for(2).value
528 529 end
529 530
530 531 def test_copy_to_another_project_and_tracker
531 532 issue = Issue.find(1)
532 533 copy = nil
533 534 assert_difference 'Issue.count' do
534 535 copy = issue.move_to_project(Project.find(3), Tracker.find(2), :copy => true)
535 536 end
536 537 copy.reload
537 538 assert_kind_of Issue, copy
538 539 assert_equal Project.find(3), copy.project
539 540 assert_equal Tracker.find(2), copy.tracker
540 541 # Custom field #2 is not associated with target tracker
541 542 assert_nil copy.custom_value_for(2)
542 543 end
543 544
544 545 context "#move_to_project" do
545 546 context "as a copy" do
546 547 setup do
547 548 @issue = Issue.find(1)
548 549 @copy = nil
549 550 end
550 551
551 552 should "not create a journal" do
552 553 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
553 554 assert_equal 0, @copy.reload.journals.size
554 555 end
555 556
556 557 should "allow assigned_to changes" do
557 558 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
558 559 assert_equal 3, @copy.assigned_to_id
559 560 end
560 561
561 562 should "allow status changes" do
562 563 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:status_id => 2}})
563 564 assert_equal 2, @copy.status_id
564 565 end
565 566
566 567 should "allow start date changes" do
567 568 date = Date.today
568 569 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})
569 570 assert_equal date, @copy.start_date
570 571 end
571 572
572 573 should "allow due date changes" do
573 574 date = Date.today
574 575 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:due_date => date}})
575 576
576 577 assert_equal date, @copy.due_date
577 578 end
578 579
579 580 should "set current user as author" do
580 581 User.current = User.find(9)
581 582 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}})
582 583
583 584 assert_equal User.current, @copy.author
584 585 end
585 586
586 587 should "keep journal notes" do
587 588 date = Date.today
588 589 notes = "Notes added when copying"
589 590 User.current = User.find(9)
590 591 @issue.init_journal(User.current, notes)
591 592 @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})
592 593
593 594 assert_equal 1, @copy.journals.size
594 595 journal = @copy.journals.first
595 596 assert_equal 0, journal.details.size
596 597 assert_equal notes, journal.notes
597 598 end
598 599 end
599 600 end
600 601
601 602 def test_recipients_should_not_include_users_that_cannot_view_the_issue
602 603 issue = Issue.find(12)
603 604 assert issue.recipients.include?(issue.author.mail)
604 605 # move the issue to a private project
605 606 copy = issue.move_to_project(Project.find(5), Tracker.find(2), :copy => true)
606 607 # author is not a member of project anymore
607 608 assert !copy.recipients.include?(copy.author.mail)
608 609 end
609 610
610 611 def test_recipients_should_include_the_assigned_group_members
611 612 group_member = User.generate_with_protected!
612 613 group = Group.generate!
613 614 group.users << group_member
614 615
615 616 issue = Issue.find(12)
616 617 issue.assigned_to = group
617 618 assert issue.recipients.include?(group_member.mail)
618 619 end
619 620
620 621 def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue
621 622 user = User.find(3)
622 623 issue = Issue.find(9)
623 624 Watcher.create!(:user => user, :watchable => issue)
624 625 assert issue.watched_by?(user)
625 626 assert !issue.watcher_recipients.include?(user.mail)
626 627 end
627 628
628 629 def test_issue_destroy
629 630 Issue.find(1).destroy
630 631 assert_nil Issue.find_by_id(1)
631 632 assert_nil TimeEntry.find_by_issue_id(1)
632 633 end
633 634
634 635 def test_blocked
635 636 blocked_issue = Issue.find(9)
636 637 blocking_issue = Issue.find(10)
637 638
638 639 assert blocked_issue.blocked?
639 640 assert !blocking_issue.blocked?
640 641 end
641 642
642 643 def test_blocked_issues_dont_allow_closed_statuses
643 644 blocked_issue = Issue.find(9)
644 645
645 646 allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
646 647 assert !allowed_statuses.empty?
647 648 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
648 649 assert closed_statuses.empty?
649 650 end
650 651
651 652 def test_unblocked_issues_allow_closed_statuses
652 653 blocking_issue = Issue.find(10)
653 654
654 655 allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
655 656 assert !allowed_statuses.empty?
656 657 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
657 658 assert !closed_statuses.empty?
658 659 end
659 660
660 661 def test_rescheduling_an_issue_should_reschedule_following_issue
661 662 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)
662 663 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)
663 664 IssueRelation.create!(:issue_from => issue1, :issue_to => issue2, :relation_type => IssueRelation::TYPE_PRECEDES)
664 665 assert_equal issue1.due_date + 1, issue2.reload.start_date
665 666
666 667 issue1.due_date = Date.today + 5
667 668 issue1.save!
668 669 assert_equal issue1.due_date + 1, issue2.reload.start_date
669 670 end
670 671
671 672 def test_overdue
672 673 assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
673 674 assert !Issue.new(:due_date => Date.today).overdue?
674 675 assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
675 676 assert !Issue.new(:due_date => nil).overdue?
676 677 assert !Issue.new(:due_date => 1.day.ago.to_date, :status => IssueStatus.find(:first, :conditions => {:is_closed => true})).overdue?
677 678 end
678 679
679 680 context "#behind_schedule?" do
680 681 should "be false if the issue has no start_date" do
681 682 assert !Issue.new(:start_date => nil, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?
682 683 end
683 684
684 685 should "be false if the issue has no end_date" do
685 686 assert !Issue.new(:start_date => 1.day.from_now.to_date, :due_date => nil, :done_ratio => 0).behind_schedule?
686 687 end
687 688
688 689 should "be false if the issue has more done than it's calendar time" do
689 690 assert !Issue.new(:start_date => 50.days.ago.to_date, :due_date => 50.days.from_now.to_date, :done_ratio => 90).behind_schedule?
690 691 end
691 692
692 693 should "be true if the issue hasn't been started at all" do
693 694 assert Issue.new(:start_date => 1.day.ago.to_date, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?
694 695 end
695 696
696 697 should "be true if the issue has used more calendar time than it's done ratio" do
697 698 assert Issue.new(:start_date => 100.days.ago.to_date, :due_date => Date.today, :done_ratio => 90).behind_schedule?
698 699 end
699 700 end
700 701
701 702 context "#assignable_users" do
702 703 should "be Users" do
703 704 assert_kind_of User, Issue.find(1).assignable_users.first
704 705 end
705 706
706 707 should "include the issue author" do
707 708 project = Project.find(1)
708 709 non_project_member = User.generate!
709 710 issue = Issue.generate_for_project!(project, :author => non_project_member)
710 711
711 712 assert issue.assignable_users.include?(non_project_member)
712 713 end
713 714
714 715 should "include the current assignee" do
715 716 project = Project.find(1)
716 717 user = User.generate!
717 718 issue = Issue.generate_for_project!(project, :assigned_to => user)
718 719 user.lock!
719 720
720 721 assert Issue.find(issue.id).assignable_users.include?(user)
721 722 end
722 723
723 724 should "not show the issue author twice" do
724 725 assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
725 726 assert_equal 2, assignable_user_ids.length
726 727
727 728 assignable_user_ids.each do |user_id|
728 729 assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once"
729 730 end
730 731 end
731 732
732 733 context "with issue_group_assignment" do
733 734 should "include groups" do
734 735 issue = Issue.new(:project => Project.find(2))
735 736
736 737 with_settings :issue_group_assignment => '1' do
737 738 assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
738 739 assert issue.assignable_users.include?(Group.find(11))
739 740 end
740 741 end
741 742 end
742 743
743 744 context "without issue_group_assignment" do
744 745 should "not include groups" do
745 746 issue = Issue.new(:project => Project.find(2))
746 747
747 748 with_settings :issue_group_assignment => '0' do
748 749 assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
749 750 assert !issue.assignable_users.include?(Group.find(11))
750 751 end
751 752 end
752 753 end
753 754 end
754 755
755 756 def test_create_should_send_email_notification
756 757 ActionMailer::Base.deliveries.clear
757 758 issue = Issue.new(:project_id => 1, :tracker_id => 1,
758 759 :author_id => 3, :status_id => 1,
759 760 :priority => IssuePriority.all.first,
760 761 :subject => 'test_create', :estimated_hours => '1:30')
761 762
762 763 assert issue.save
763 764 assert_equal 1, ActionMailer::Base.deliveries.size
764 765 end
765 766
766 767 def test_stale_issue_should_not_send_email_notification
767 768 ActionMailer::Base.deliveries.clear
768 769 issue = Issue.find(1)
769 770 stale = Issue.find(1)
770 771
771 772 issue.init_journal(User.find(1))
772 773 issue.subject = 'Subjet update'
773 774 assert issue.save
774 775 assert_equal 1, ActionMailer::Base.deliveries.size
775 776 ActionMailer::Base.deliveries.clear
776 777
777 778 stale.init_journal(User.find(1))
778 779 stale.subject = 'Another subjet update'
779 780 assert_raise ActiveRecord::StaleObjectError do
780 781 stale.save
781 782 end
782 783 assert ActionMailer::Base.deliveries.empty?
783 784 end
784 785
785 786 def test_journalized_description
786 787 IssueCustomField.delete_all
787 788
788 789 i = Issue.first
789 790 old_description = i.description
790 791 new_description = "This is the new description"
791 792
792 793 i.init_journal(User.find(2))
793 794 i.description = new_description
794 795 assert_difference 'Journal.count', 1 do
795 796 assert_difference 'JournalDetail.count', 1 do
796 797 i.save!
797 798 end
798 799 end
799 800
800 801 detail = JournalDetail.first(:order => 'id DESC')
801 802 assert_equal i, detail.journal.journalized
802 803 assert_equal 'attr', detail.property
803 804 assert_equal 'description', detail.prop_key
804 805 assert_equal old_description, detail.old_value
805 806 assert_equal new_description, detail.value
806 807 end
807 808
808 809 def test_blank_descriptions_should_not_be_journalized
809 810 IssueCustomField.delete_all
810 811 Issue.update_all("description = NULL", "id=1")
811 812
812 813 i = Issue.find(1)
813 814 i.init_journal(User.find(2))
814 815 i.subject = "blank description"
815 816 i.description = "\r\n"
816 817
817 818 assert_difference 'Journal.count', 1 do
818 819 assert_difference 'JournalDetail.count', 1 do
819 820 i.save!
820 821 end
821 822 end
822 823 end
823 824
824 825 def test_description_eol_should_be_normalized
825 826 i = Issue.new(:description => "CR \r LF \n CRLF \r\n")
826 827 assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description
827 828 end
828 829
829 830 def test_saving_twice_should_not_duplicate_journal_details
830 831 i = Issue.find(:first)
831 832 i.init_journal(User.find(2), 'Some notes')
832 833 # initial changes
833 834 i.subject = 'New subject'
834 835 i.done_ratio = i.done_ratio + 10
835 836 assert_difference 'Journal.count' do
836 837 assert i.save
837 838 end
838 839 # 1 more change
839 840 i.priority = IssuePriority.find(:first, :conditions => ["id <> ?", i.priority_id])
840 841 assert_no_difference 'Journal.count' do
841 842 assert_difference 'JournalDetail.count', 1 do
842 843 i.save
843 844 end
844 845 end
845 846 # no more change
846 847 assert_no_difference 'Journal.count' do
847 848 assert_no_difference 'JournalDetail.count' do
848 849 i.save
849 850 end
850 851 end
851 852 end
852 853
853 854 def test_all_dependent_issues
854 855 IssueRelation.delete_all
855 856 assert IssueRelation.create!(:issue_from => Issue.find(1),
856 857 :issue_to => Issue.find(2),
857 858 :relation_type => IssueRelation::TYPE_PRECEDES)
858 859 assert IssueRelation.create!(:issue_from => Issue.find(2),
859 860 :issue_to => Issue.find(3),
860 861 :relation_type => IssueRelation::TYPE_PRECEDES)
861 862 assert IssueRelation.create!(:issue_from => Issue.find(3),
862 863 :issue_to => Issue.find(8),
863 864 :relation_type => IssueRelation::TYPE_PRECEDES)
864 865
865 866 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
866 867 end
867 868
868 869 def test_all_dependent_issues_with_persistent_circular_dependency
869 870 IssueRelation.delete_all
870 871 assert IssueRelation.create!(:issue_from => Issue.find(1),
871 872 :issue_to => Issue.find(2),
872 873 :relation_type => IssueRelation::TYPE_PRECEDES)
873 874 assert IssueRelation.create!(:issue_from => Issue.find(2),
874 875 :issue_to => Issue.find(3),
875 876 :relation_type => IssueRelation::TYPE_PRECEDES)
876 877 # Validation skipping
877 878 assert IssueRelation.new(:issue_from => Issue.find(3),
878 879 :issue_to => Issue.find(1),
879 880 :relation_type => IssueRelation::TYPE_PRECEDES).save(false)
880 881
881 882 assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
882 883 end
883 884
884 885 def test_all_dependent_issues_with_persistent_multiple_circular_dependencies
885 886 IssueRelation.delete_all
886 887 assert IssueRelation.create!(:issue_from => Issue.find(1),
887 888 :issue_to => Issue.find(2),
888 889 :relation_type => IssueRelation::TYPE_RELATES)
889 890 assert IssueRelation.create!(:issue_from => Issue.find(2),
890 891 :issue_to => Issue.find(3),
891 892 :relation_type => IssueRelation::TYPE_RELATES)
892 893 assert IssueRelation.create!(:issue_from => Issue.find(3),
893 894 :issue_to => Issue.find(8),
894 895 :relation_type => IssueRelation::TYPE_RELATES)
895 896 # Validation skipping
896 897 assert IssueRelation.new(:issue_from => Issue.find(8),
897 898 :issue_to => Issue.find(2),
898 899 :relation_type => IssueRelation::TYPE_RELATES).save(false)
899 900 assert IssueRelation.new(:issue_from => Issue.find(3),
900 901 :issue_to => Issue.find(1),
901 902 :relation_type => IssueRelation::TYPE_RELATES).save(false)
902 903
903 904 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
904 905 end
905 906
906 907 context "#done_ratio" do
907 908 setup do
908 909 @issue = Issue.find(1)
909 910 @issue_status = IssueStatus.find(1)
910 911 @issue_status.update_attribute(:default_done_ratio, 50)
911 912 @issue2 = Issue.find(2)
912 913 @issue_status2 = IssueStatus.find(2)
913 914 @issue_status2.update_attribute(:default_done_ratio, 0)
914 915 end
915 916
916 917 context "with Setting.issue_done_ratio using the issue_field" do
917 918 setup do
918 919 Setting.issue_done_ratio = 'issue_field'
919 920 end
920 921
921 922 should "read the issue's field" do
922 923 assert_equal 0, @issue.done_ratio
923 924 assert_equal 30, @issue2.done_ratio
924 925 end
925 926 end
926 927
927 928 context "with Setting.issue_done_ratio using the issue_status" do
928 929 setup do
929 930 Setting.issue_done_ratio = 'issue_status'
930 931 end
931 932
932 933 should "read the Issue Status's default done ratio" do
933 934 assert_equal 50, @issue.done_ratio
934 935 assert_equal 0, @issue2.done_ratio
935 936 end
936 937 end
937 938 end
938 939
939 940 context "#update_done_ratio_from_issue_status" do
940 941 setup do
941 942 @issue = Issue.find(1)
942 943 @issue_status = IssueStatus.find(1)
943 944 @issue_status.update_attribute(:default_done_ratio, 50)
944 945 @issue2 = Issue.find(2)
945 946 @issue_status2 = IssueStatus.find(2)
946 947 @issue_status2.update_attribute(:default_done_ratio, 0)
947 948 end
948 949
949 950 context "with Setting.issue_done_ratio using the issue_field" do
950 951 setup do
951 952 Setting.issue_done_ratio = 'issue_field'
952 953 end
953 954
954 955 should "not change the issue" do
955 956 @issue.update_done_ratio_from_issue_status
956 957 @issue2.update_done_ratio_from_issue_status
957 958
958 959 assert_equal 0, @issue.read_attribute(:done_ratio)
959 960 assert_equal 30, @issue2.read_attribute(:done_ratio)
960 961 end
961 962 end
962 963
963 964 context "with Setting.issue_done_ratio using the issue_status" do
964 965 setup do
965 966 Setting.issue_done_ratio = 'issue_status'
966 967 end
967 968
968 969 should "change the issue's done ratio" do
969 970 @issue.update_done_ratio_from_issue_status
970 971 @issue2.update_done_ratio_from_issue_status
971 972
972 973 assert_equal 50, @issue.read_attribute(:done_ratio)
973 974 assert_equal 0, @issue2.read_attribute(:done_ratio)
974 975 end
975 976 end
976 977 end
977 978
978 979 test "#by_tracker" do
979 980 User.current = User.anonymous
980 981 groups = Issue.by_tracker(Project.find(1))
981 982 assert_equal 3, groups.size
982 983 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
983 984 end
984 985
985 986 test "#by_version" do
986 987 User.current = User.anonymous
987 988 groups = Issue.by_version(Project.find(1))
988 989 assert_equal 3, groups.size
989 990 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
990 991 end
991 992
992 993 test "#by_priority" do
993 994 User.current = User.anonymous
994 995 groups = Issue.by_priority(Project.find(1))
995 996 assert_equal 4, groups.size
996 997 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
997 998 end
998 999
999 1000 test "#by_category" do
1000 1001 User.current = User.anonymous
1001 1002 groups = Issue.by_category(Project.find(1))
1002 1003 assert_equal 2, groups.size
1003 1004 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
1004 1005 end
1005 1006
1006 1007 test "#by_assigned_to" do
1007 1008 User.current = User.anonymous
1008 1009 groups = Issue.by_assigned_to(Project.find(1))
1009 1010 assert_equal 2, groups.size
1010 1011 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
1011 1012 end
1012 1013
1013 1014 test "#by_author" do
1014 1015 User.current = User.anonymous
1015 1016 groups = Issue.by_author(Project.find(1))
1016 1017 assert_equal 4, groups.size
1017 1018 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
1018 1019 end
1019 1020
1020 1021 test "#by_subproject" do
1021 1022 User.current = User.anonymous
1022 1023 groups = Issue.by_subproject(Project.find(1))
1023 1024 # Private descendant not visible
1024 1025 assert_equal 1, groups.size
1025 1026 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
1026 1027 end
1027 1028
1028 1029 context ".allowed_target_projects_on_move" do
1029 1030 should "return all active projects for admin users" do
1030 1031 User.current = User.find(1)
1031 1032 assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
1032 1033 end
1033 1034
1034 1035 should "return allowed projects for non admin users" do
1035 1036 User.current = User.find(2)
1036 1037 Role.non_member.remove_permission! :move_issues
1037 1038 assert_equal 3, Issue.allowed_target_projects_on_move.size
1038 1039
1039 1040 Role.non_member.add_permission! :move_issues
1040 1041 assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
1041 1042 end
1042 1043 end
1043 1044
1044 1045 def test_recently_updated_with_limit_scopes
1045 1046 #should return the last updated issue
1046 1047 assert_equal 1, Issue.recently_updated.with_limit(1).length
1047 1048 assert_equal Issue.find(:first, :order => "updated_on DESC"), Issue.recently_updated.with_limit(1).first
1048 1049 end
1049 1050
1050 1051 def test_on_active_projects_scope
1051 1052 assert Project.find(2).archive
1052 1053
1053 1054 before = Issue.on_active_project.length
1054 1055 # test inclusion to results
1055 1056 issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first)
1056 1057 assert_equal before + 1, Issue.on_active_project.length
1057 1058
1058 1059 # Move to an archived project
1059 1060 issue.project = Project.find(2)
1060 1061 assert issue.save
1061 1062 assert_equal before, Issue.on_active_project.length
1062 1063 end
1063 1064
1064 1065 context "Issue#recipients" do
1065 1066 setup do
1066 1067 @project = Project.find(1)
1067 1068 @author = User.generate_with_protected!
1068 1069 @assignee = User.generate_with_protected!
1069 1070 @issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author)
1070 1071 end
1071 1072
1072 1073 should "include project recipients" do
1073 1074 assert @project.recipients.present?
1074 1075 @project.recipients.each do |project_recipient|
1075 1076 assert @issue.recipients.include?(project_recipient)
1076 1077 end
1077 1078 end
1078 1079
1079 1080 should "include the author if the author is active" do
1080 1081 assert @issue.author, "No author set for Issue"
1081 1082 assert @issue.recipients.include?(@issue.author.mail)
1082 1083 end
1083 1084
1084 1085 should "include the assigned to user if the assigned to user is active" do
1085 1086 assert @issue.assigned_to, "No assigned_to set for Issue"
1086 1087 assert @issue.recipients.include?(@issue.assigned_to.mail)
1087 1088 end
1088 1089
1089 1090 should "not include users who opt out of all email" do
1090 1091 @author.update_attribute(:mail_notification, :none)
1091 1092
1092 1093 assert !@issue.recipients.include?(@issue.author.mail)
1093 1094 end
1094 1095
1095 1096 should "not include the issue author if they are only notified of assigned issues" do
1096 1097 @author.update_attribute(:mail_notification, :only_assigned)
1097 1098
1098 1099 assert !@issue.recipients.include?(@issue.author.mail)
1099 1100 end
1100 1101
1101 1102 should "not include the assigned user if they are only notified of owned issues" do
1102 1103 @assignee.update_attribute(:mail_notification, :only_owner)
1103 1104
1104 1105 assert !@issue.recipients.include?(@issue.assigned_to.mail)
1105 1106 end
1106 1107
1107 1108 end
1108 1109 end
General Comments 0
You need to be logged in to leave comments. Login now