##// END OF EJS Templates
jro_apps » redmine
RSS
remove unneeded Relation#all from ProjectTest#test_destroy...
Toshi MARUYAMA -
r12281:7960f543a401
parent child
Show More
Side by Side Unified
Context file:
r12281:7960f543a401 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,945 +1,945
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2013 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 ProjectTest < ActiveSupport::TestCase
21 21 fixtures :projects, :trackers, :issue_statuses, :issues,
22 22 :journals, :journal_details,
23 23 :enumerations, :users, :issue_categories,
24 24 :projects_trackers,
25 25 :custom_fields,
26 26 :custom_fields_projects,
27 27 :custom_fields_trackers,
28 28 :custom_values,
29 29 :roles,
30 30 :member_roles,
31 31 :members,
32 32 :enabled_modules,
33 33 :versions,
34 34 :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
35 35 :groups_users,
36 36 :boards, :messages,
37 37 :repositories,
38 38 :news, :comments,
39 39 :documents
40 40
41 41 def setup
42 42 @ecookbook = Project.find(1)
43 43 @ecookbook_sub1 = Project.find(3)
44 44 set_tmp_attachments_directory
45 45 User.current = nil
46 46 end
47 47
48 48 def test_truth
49 49 assert_kind_of Project, @ecookbook
50 50 assert_equal "eCookbook", @ecookbook.name
51 51 end
52 52
53 53 def test_default_attributes
54 54 with_settings :default_projects_public => '1' do
55 55 assert_equal true, Project.new.is_public
56 56 assert_equal false, Project.new(:is_public => false).is_public
57 57 end
58 58
59 59 with_settings :default_projects_public => '0' do
60 60 assert_equal false, Project.new.is_public
61 61 assert_equal true, Project.new(:is_public => true).is_public
62 62 end
63 63
64 64 with_settings :sequential_project_identifiers => '1' do
65 65 assert !Project.new.identifier.blank?
66 66 assert Project.new(:identifier => '').identifier.blank?
67 67 end
68 68
69 69 with_settings :sequential_project_identifiers => '0' do
70 70 assert Project.new.identifier.blank?
71 71 assert !Project.new(:identifier => 'test').blank?
72 72 end
73 73
74 74 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
75 75 assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names
76 76 end
77 77 end
78 78
79 79 def test_default_trackers_should_match_default_tracker_ids_setting
80 80 with_settings :default_projects_tracker_ids => ['1', '3'] do
81 81 assert_equal Tracker.find(1, 3).sort, Project.new.trackers.sort
82 82 end
83 83 end
84 84
85 85 def test_default_trackers_should_be_all_trackers_with_blank_setting
86 86 with_settings :default_projects_tracker_ids => nil do
87 87 assert_equal Tracker.all.sort, Project.new.trackers.sort
88 88 end
89 89 end
90 90
91 91 def test_default_trackers_should_be_empty_with_empty_setting
92 92 with_settings :default_projects_tracker_ids => [] do
93 93 assert_equal [], Project.new.trackers
94 94 end
95 95 end
96 96
97 97 def test_default_trackers_should_not_replace_initialized_trackers
98 98 with_settings :default_projects_tracker_ids => ['1', '3'] do
99 99 assert_equal Tracker.find(1, 2).sort, Project.new(:tracker_ids => [1, 2]).trackers.sort
100 100 end
101 101 end
102 102
103 103 def test_update
104 104 assert_equal "eCookbook", @ecookbook.name
105 105 @ecookbook.name = "eCook"
106 106 assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
107 107 @ecookbook.reload
108 108 assert_equal "eCook", @ecookbook.name
109 109 end
110 110
111 111 def test_validate_identifier
112 112 to_test = {"abc" => true,
113 113 "ab12" => true,
114 114 "ab-12" => true,
115 115 "ab_12" => true,
116 116 "12" => false,
117 117 "new" => false}
118 118
119 119 to_test.each do |identifier, valid|
120 120 p = Project.new
121 121 p.identifier = identifier
122 122 p.valid?
123 123 if valid
124 124 assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"
125 125 else
126 126 assert p.errors['identifier'].present?, "identifier #{identifier} was valid"
127 127 end
128 128 end
129 129 end
130 130
131 131 def test_identifier_should_not_be_frozen_for_a_new_project
132 132 assert_equal false, Project.new.identifier_frozen?
133 133 end
134 134
135 135 def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier
136 136 Project.where(:id => 1).update_all(["identifier = ''"])
137 137 assert_equal false, Project.find(1).identifier_frozen?
138 138 end
139 139
140 140 def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier
141 141 assert_equal true, Project.find(1).identifier_frozen?
142 142 end
143 143
144 144 def test_members_should_be_active_users
145 145 Project.all.each do |project|
146 146 assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }
147 147 end
148 148 end
149 149
150 150 def test_users_should_be_active_users
151 151 Project.all.each do |project|
152 152 assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }
153 153 end
154 154 end
155 155
156 156 def test_open_scope_on_issues_association
157 157 assert_kind_of Issue, Project.find(1).issues.open.first
158 158 end
159 159
160 160 def test_archive
161 161 user = @ecookbook.members.first.user
162 162 @ecookbook.archive
163 163 @ecookbook.reload
164 164
165 165 assert !@ecookbook.active?
166 166 assert @ecookbook.archived?
167 167 assert !user.projects.include?(@ecookbook)
168 168 # Subproject are also archived
169 169 assert !@ecookbook.children.empty?
170 170 assert @ecookbook.descendants.active.empty?
171 171 end
172 172
173 173 def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects
174 174 # Assign an issue of a project to a version of a child project
175 175 Issue.find(4).update_attribute :fixed_version_id, 4
176 176
177 177 assert_no_difference "Project.where(:status => Project::STATUS_ARCHIVED).count" do
178 178 assert_equal false, @ecookbook.archive
179 179 end
180 180 @ecookbook.reload
181 181 assert @ecookbook.active?
182 182 end
183 183
184 184 def test_unarchive
185 185 user = @ecookbook.members.first.user
186 186 @ecookbook.archive
187 187 # A subproject of an archived project can not be unarchived
188 188 assert !@ecookbook_sub1.unarchive
189 189
190 190 # Unarchive project
191 191 assert @ecookbook.unarchive
192 192 @ecookbook.reload
193 193 assert @ecookbook.active?
194 194 assert !@ecookbook.archived?
195 195 assert user.projects.include?(@ecookbook)
196 196 # Subproject can now be unarchived
197 197 @ecookbook_sub1.reload
198 198 assert @ecookbook_sub1.unarchive
199 199 end
200 200
201 201 def test_destroy
202 202 # 2 active members
203 203 assert_equal 2, @ecookbook.members.size
204 204 # and 1 is locked
205 assert_equal 3, Member.where('project_id = ?', @ecookbook.id).all.size
205 assert_equal 3, Member.where(:project_id => @ecookbook.id).count
206 206 # some boards
207 207 assert @ecookbook.boards.any?
208 208
209 209 @ecookbook.destroy
210 210 # make sure that the project non longer exists
211 211 assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
212 212 # make sure related data was removed
213 213 assert_nil Member.where(:project_id => @ecookbook.id).first
214 214 assert_nil Board.where(:project_id => @ecookbook.id).first
215 215 assert_nil Issue.where(:project_id => @ecookbook.id).first
216 216 end
217 217
218 218 def test_destroy_should_destroy_subtasks
219 219 issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}
220 220 issues[0].update_attribute :parent_issue_id, issues[1].id
221 221 issues[2].update_attribute :parent_issue_id, issues[1].id
222 222 assert_equal 2, issues[1].children.count
223 223
224 224 assert_nothing_raised do
225 225 Project.find(1).destroy
226 226 end
227 227 assert Issue.find_all_by_id(issues.map(&:id)).empty?
228 228 end
229 229
230 230 def test_destroying_root_projects_should_clear_data
231 231 Project.roots.each do |root|
232 232 root.destroy
233 233 end
234 234
235 235 assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"
236 236 assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"
237 237 assert_equal 0, MemberRole.count
238 238 assert_equal 0, Issue.count
239 239 assert_equal 0, Journal.count
240 240 assert_equal 0, JournalDetail.count
241 241 assert_equal 0, Attachment.count, "Attachments were not deleted: #{Attachment.all.inspect}"
242 242 assert_equal 0, EnabledModule.count
243 243 assert_equal 0, IssueCategory.count
244 244 assert_equal 0, IssueRelation.count
245 245 assert_equal 0, Board.count
246 246 assert_equal 0, Message.count
247 247 assert_equal 0, News.count
248 248 assert_equal 0, Query.where("project_id IS NOT NULL").count
249 249 assert_equal 0, Repository.count
250 250 assert_equal 0, Changeset.count
251 251 assert_equal 0, Change.count
252 252 assert_equal 0, Comment.count
253 253 assert_equal 0, TimeEntry.count
254 254 assert_equal 0, Version.count
255 255 assert_equal 0, Watcher.count
256 256 assert_equal 0, Wiki.count
257 257 assert_equal 0, WikiPage.count
258 258 assert_equal 0, WikiContent.count
259 259 assert_equal 0, WikiContent::Version.count
260 260 assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").count
261 261 assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").count
262 262 assert_equal 0, CustomValue.where(:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']).count
263 263 end
264 264
265 265 def test_destroy_should_delete_time_entries_custom_values
266 266 project = Project.generate!
267 267 time_entry = TimeEntry.generate!(:project => project, :custom_field_values => {10 => '1'})
268 268
269 269 assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do
270 270 assert project.destroy
271 271 end
272 272 end
273 273
274 274 def test_move_an_orphan_project_to_a_root_project
275 275 sub = Project.find(2)
276 276 sub.set_parent! @ecookbook
277 277 assert_equal @ecookbook.id, sub.parent.id
278 278 @ecookbook.reload
279 279 assert_equal 4, @ecookbook.children.size
280 280 end
281 281
282 282 def test_move_an_orphan_project_to_a_subproject
283 283 sub = Project.find(2)
284 284 assert sub.set_parent!(@ecookbook_sub1)
285 285 end
286 286
287 287 def test_move_a_root_project_to_a_project
288 288 sub = @ecookbook
289 289 assert sub.set_parent!(Project.find(2))
290 290 end
291 291
292 292 def test_should_not_move_a_project_to_its_children
293 293 sub = @ecookbook
294 294 assert !(sub.set_parent!(Project.find(3)))
295 295 end
296 296
297 297 def test_set_parent_should_add_roots_in_alphabetical_order
298 298 ProjectCustomField.delete_all
299 299 Project.delete_all
300 300 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
301 301 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
302 302 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
303 303 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
304 304
305 305 assert_equal 4, Project.count
306 306 assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
307 307 end
308 308
309 309 def test_set_parent_should_add_children_in_alphabetical_order
310 310 ProjectCustomField.delete_all
311 311 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
312 312 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
313 313 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
314 314 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
315 315 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
316 316
317 317 parent.reload
318 318 assert_equal 4, parent.children.size
319 319 assert_equal parent.children.all.sort_by(&:name), parent.children.all
320 320 end
321 321
322 322 def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy
323 323 # Parent issue with a hierarchy project's fixed version
324 324 parent_issue = Issue.find(1)
325 325 parent_issue.update_attribute(:fixed_version_id, 4)
326 326 parent_issue.reload
327 327 assert_equal 4, parent_issue.fixed_version_id
328 328
329 329 # Should keep fixed versions for the issues
330 330 issue_with_local_fixed_version = Issue.find(5)
331 331 issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)
332 332 issue_with_local_fixed_version.reload
333 333 assert_equal 4, issue_with_local_fixed_version.fixed_version_id
334 334
335 335 # Local issue with hierarchy fixed_version
336 336 issue_with_hierarchy_fixed_version = Issue.find(13)
337 337 issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)
338 338 issue_with_hierarchy_fixed_version.reload
339 339 assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id
340 340
341 341 # Move project out of the issue's hierarchy
342 342 moved_project = Project.find(3)
343 343 moved_project.set_parent!(Project.find(2))
344 344 parent_issue.reload
345 345 issue_with_local_fixed_version.reload
346 346 issue_with_hierarchy_fixed_version.reload
347 347
348 348 assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"
349 349 assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"
350 350 assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."
351 351 end
352 352
353 353 def test_parent
354 354 p = Project.find(6).parent
355 355 assert p.is_a?(Project)
356 356 assert_equal 5, p.id
357 357 end
358 358
359 359 def test_ancestors
360 360 a = Project.find(6).ancestors
361 361 assert a.first.is_a?(Project)
362 362 assert_equal [1, 5], a.collect(&:id)
363 363 end
364 364
365 365 def test_root
366 366 r = Project.find(6).root
367 367 assert r.is_a?(Project)
368 368 assert_equal 1, r.id
369 369 end
370 370
371 371 def test_children
372 372 c = Project.find(1).children
373 373 assert c.first.is_a?(Project)
374 374 assert_equal [5, 3, 4], c.collect(&:id)
375 375 end
376 376
377 377 def test_descendants
378 378 d = Project.find(1).descendants
379 379 assert d.first.is_a?(Project)
380 380 assert_equal [5, 6, 3, 4], d.collect(&:id)
381 381 end
382 382
383 383 def test_allowed_parents_should_be_empty_for_non_member_user
384 384 Role.non_member.add_permission!(:add_project)
385 385 user = User.find(9)
386 386 assert user.memberships.empty?
387 387 User.current = user
388 388 assert Project.new.allowed_parents.compact.empty?
389 389 end
390 390
391 391 def test_allowed_parents_with_add_subprojects_permission
392 392 Role.find(1).remove_permission!(:add_project)
393 393 Role.find(1).add_permission!(:add_subprojects)
394 394 User.current = User.find(2)
395 395 # new project
396 396 assert !Project.new.allowed_parents.include?(nil)
397 397 assert Project.new.allowed_parents.include?(Project.find(1))
398 398 # existing root project
399 399 assert Project.find(1).allowed_parents.include?(nil)
400 400 # existing child
401 401 assert Project.find(3).allowed_parents.include?(Project.find(1))
402 402 assert !Project.find(3).allowed_parents.include?(nil)
403 403 end
404 404
405 405 def test_allowed_parents_with_add_project_permission
406 406 Role.find(1).add_permission!(:add_project)
407 407 Role.find(1).remove_permission!(:add_subprojects)
408 408 User.current = User.find(2)
409 409 # new project
410 410 assert Project.new.allowed_parents.include?(nil)
411 411 assert !Project.new.allowed_parents.include?(Project.find(1))
412 412 # existing root project
413 413 assert Project.find(1).allowed_parents.include?(nil)
414 414 # existing child
415 415 assert Project.find(3).allowed_parents.include?(Project.find(1))
416 416 assert Project.find(3).allowed_parents.include?(nil)
417 417 end
418 418
419 419 def test_allowed_parents_with_add_project_and_subprojects_permission
420 420 Role.find(1).add_permission!(:add_project)
421 421 Role.find(1).add_permission!(:add_subprojects)
422 422 User.current = User.find(2)
423 423 # new project
424 424 assert Project.new.allowed_parents.include?(nil)
425 425 assert Project.new.allowed_parents.include?(Project.find(1))
426 426 # existing root project
427 427 assert Project.find(1).allowed_parents.include?(nil)
428 428 # existing child
429 429 assert Project.find(3).allowed_parents.include?(Project.find(1))
430 430 assert Project.find(3).allowed_parents.include?(nil)
431 431 end
432 432
433 433 def test_users_by_role
434 434 users_by_role = Project.find(1).users_by_role
435 435 assert_kind_of Hash, users_by_role
436 436 role = Role.find(1)
437 437 assert_kind_of Array, users_by_role[role]
438 438 assert users_by_role[role].include?(User.find(2))
439 439 end
440 440
441 441 def test_rolled_up_trackers
442 442 parent = Project.find(1)
443 443 parent.trackers = Tracker.find([1,2])
444 444 child = parent.children.find(3)
445 445
446 446 assert_equal [1, 2], parent.tracker_ids
447 447 assert_equal [2, 3], child.trackers.collect(&:id)
448 448
449 449 assert_kind_of Tracker, parent.rolled_up_trackers.first
450 450 assert_equal Tracker.find(1), parent.rolled_up_trackers.first
451 451
452 452 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
453 453 assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
454 454 end
455 455
456 456 def test_rolled_up_trackers_should_ignore_archived_subprojects
457 457 parent = Project.find(1)
458 458 parent.trackers = Tracker.find([1,2])
459 459 child = parent.children.find(3)
460 460 child.trackers = Tracker.find([1,3])
461 461 parent.children.each(&:archive)
462 462
463 463 assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)
464 464 end
465 465
466 466 test "#rolled_up_trackers should ignore projects with issue_tracking module disabled" do
467 467 parent = Project.generate!
468 468 parent.trackers = Tracker.find([1, 2])
469 469 child = Project.generate_with_parent!(parent)
470 470 child.trackers = Tracker.find([2, 3])
471 471
472 472 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id).sort
473 473
474 474 assert child.disable_module!(:issue_tracking)
475 475 parent.reload
476 476 assert_equal [1, 2], parent.rolled_up_trackers.collect(&:id).sort
477 477 end
478 478
479 479 test "#rolled_up_versions should include the versions for the current project" do
480 480 project = Project.generate!
481 481 parent_version_1 = Version.generate!(:project => project)
482 482 parent_version_2 = Version.generate!(:project => project)
483 483 assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
484 484 end
485 485
486 486 test "#rolled_up_versions should include versions for a subproject" do
487 487 project = Project.generate!
488 488 parent_version_1 = Version.generate!(:project => project)
489 489 parent_version_2 = Version.generate!(:project => project)
490 490 subproject = Project.generate_with_parent!(project)
491 491 subproject_version = Version.generate!(:project => subproject)
492 492
493 493 assert_same_elements [
494 494 parent_version_1,
495 495 parent_version_2,
496 496 subproject_version
497 497 ], project.rolled_up_versions
498 498 end
499 499
500 500 test "#rolled_up_versions should include versions for a sub-subproject" do
501 501 project = Project.generate!
502 502 parent_version_1 = Version.generate!(:project => project)
503 503 parent_version_2 = Version.generate!(:project => project)
504 504 subproject = Project.generate_with_parent!(project)
505 505 sub_subproject = Project.generate_with_parent!(subproject)
506 506 sub_subproject_version = Version.generate!(:project => sub_subproject)
507 507 project.reload
508 508
509 509 assert_same_elements [
510 510 parent_version_1,
511 511 parent_version_2,
512 512 sub_subproject_version
513 513 ], project.rolled_up_versions
514 514 end
515 515
516 516 test "#rolled_up_versions should only check active projects" do
517 517 project = Project.generate!
518 518 parent_version_1 = Version.generate!(:project => project)
519 519 parent_version_2 = Version.generate!(:project => project)
520 520 subproject = Project.generate_with_parent!(project)
521 521 subproject_version = Version.generate!(:project => subproject)
522 522 assert subproject.archive
523 523 project.reload
524 524
525 525 assert !subproject.active?
526 526 assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
527 527 end
528 528
529 529 def test_shared_versions_none_sharing
530 530 p = Project.find(5)
531 531 v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')
532 532 assert p.shared_versions.include?(v)
533 533 assert !p.children.first.shared_versions.include?(v)
534 534 assert !p.root.shared_versions.include?(v)
535 535 assert !p.siblings.first.shared_versions.include?(v)
536 536 assert !p.root.siblings.first.shared_versions.include?(v)
537 537 end
538 538
539 539 def test_shared_versions_descendants_sharing
540 540 p = Project.find(5)
541 541 v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')
542 542 assert p.shared_versions.include?(v)
543 543 assert p.children.first.shared_versions.include?(v)
544 544 assert !p.root.shared_versions.include?(v)
545 545 assert !p.siblings.first.shared_versions.include?(v)
546 546 assert !p.root.siblings.first.shared_versions.include?(v)
547 547 end
548 548
549 549 def test_shared_versions_hierarchy_sharing
550 550 p = Project.find(5)
551 551 v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')
552 552 assert p.shared_versions.include?(v)
553 553 assert p.children.first.shared_versions.include?(v)
554 554 assert p.root.shared_versions.include?(v)
555 555 assert !p.siblings.first.shared_versions.include?(v)
556 556 assert !p.root.siblings.first.shared_versions.include?(v)
557 557 end
558 558
559 559 def test_shared_versions_tree_sharing
560 560 p = Project.find(5)
561 561 v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')
562 562 assert p.shared_versions.include?(v)
563 563 assert p.children.first.shared_versions.include?(v)
564 564 assert p.root.shared_versions.include?(v)
565 565 assert p.siblings.first.shared_versions.include?(v)
566 566 assert !p.root.siblings.first.shared_versions.include?(v)
567 567 end
568 568
569 569 def test_shared_versions_system_sharing
570 570 p = Project.find(5)
571 571 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
572 572 assert p.shared_versions.include?(v)
573 573 assert p.children.first.shared_versions.include?(v)
574 574 assert p.root.shared_versions.include?(v)
575 575 assert p.siblings.first.shared_versions.include?(v)
576 576 assert p.root.siblings.first.shared_versions.include?(v)
577 577 end
578 578
579 579 def test_shared_versions
580 580 parent = Project.find(1)
581 581 child = parent.children.find(3)
582 582 private_child = parent.children.find(5)
583 583
584 584 assert_equal [1,2,3], parent.version_ids.sort
585 585 assert_equal [4], child.version_ids
586 586 assert_equal [6], private_child.version_ids
587 587 assert_equal [7], Version.where(:sharing => 'system').all.collect(&:id)
588 588
589 589 assert_equal 6, parent.shared_versions.size
590 590 parent.shared_versions.each do |version|
591 591 assert_kind_of Version, version
592 592 end
593 593
594 594 assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort
595 595 end
596 596
597 597 def test_shared_versions_should_ignore_archived_subprojects
598 598 parent = Project.find(1)
599 599 child = parent.children.find(3)
600 600 child.archive
601 601 parent.reload
602 602
603 603 assert_equal [1,2,3], parent.version_ids.sort
604 604 assert_equal [4], child.version_ids
605 605 assert !parent.shared_versions.collect(&:id).include?(4)
606 606 end
607 607
608 608 def test_shared_versions_visible_to_user
609 609 user = User.find(3)
610 610 parent = Project.find(1)
611 611 child = parent.children.find(5)
612 612
613 613 assert_equal [1,2,3], parent.version_ids.sort
614 614 assert_equal [6], child.version_ids
615 615
616 616 versions = parent.shared_versions.visible(user)
617 617
618 618 assert_equal 4, versions.size
619 619 versions.each do |version|
620 620 assert_kind_of Version, version
621 621 end
622 622
623 623 assert !versions.collect(&:id).include?(6)
624 624 end
625 625
626 626 def test_shared_versions_for_new_project_should_include_system_shared_versions
627 627 p = Project.find(5)
628 628 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
629 629
630 630 assert_include v, Project.new.shared_versions
631 631 end
632 632
633 633 def test_next_identifier
634 634 ProjectCustomField.delete_all
635 635 Project.create!(:name => 'last', :identifier => 'p2008040')
636 636 assert_equal 'p2008041', Project.next_identifier
637 637 end
638 638
639 639 def test_next_identifier_first_project
640 640 Project.delete_all
641 641 assert_nil Project.next_identifier
642 642 end
643 643
644 644 def test_enabled_module_names
645 645 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
646 646 project = Project.new
647 647
648 648 project.enabled_module_names = %w(issue_tracking news)
649 649 assert_equal %w(issue_tracking news), project.enabled_module_names.sort
650 650 end
651 651 end
652 652
653 653 test "enabled_modules should define module by names and preserve ids" do
654 654 @project = Project.find(1)
655 655 # Remove one module
656 656 modules = @project.enabled_modules.slice(0..-2)
657 657 assert modules.any?
658 658 assert_difference 'EnabledModule.count', -1 do
659 659 @project.enabled_module_names = modules.collect(&:name)
660 660 end
661 661 @project.reload
662 662 # Ids should be preserved
663 663 assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
664 664 end
665 665
666 666 test "enabled_modules should enable a module" do
667 667 @project = Project.find(1)
668 668 @project.enabled_module_names = []
669 669 @project.reload
670 670 assert_equal [], @project.enabled_module_names
671 671 #with string
672 672 @project.enable_module!("issue_tracking")
673 673 assert_equal ["issue_tracking"], @project.enabled_module_names
674 674 #with symbol
675 675 @project.enable_module!(:gantt)
676 676 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
677 677 #don't add a module twice
678 678 @project.enable_module!("issue_tracking")
679 679 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
680 680 end
681 681
682 682 test "enabled_modules should disable a module" do
683 683 @project = Project.find(1)
684 684 #with string
685 685 assert @project.enabled_module_names.include?("issue_tracking")
686 686 @project.disable_module!("issue_tracking")
687 687 assert ! @project.reload.enabled_module_names.include?("issue_tracking")
688 688 #with symbol
689 689 assert @project.enabled_module_names.include?("gantt")
690 690 @project.disable_module!(:gantt)
691 691 assert ! @project.reload.enabled_module_names.include?("gantt")
692 692 #with EnabledModule object
693 693 first_module = @project.enabled_modules.first
694 694 @project.disable_module!(first_module)
695 695 assert ! @project.reload.enabled_module_names.include?(first_module.name)
696 696 end
697 697
698 698 def test_enabled_module_names_should_not_recreate_enabled_modules
699 699 project = Project.find(1)
700 700 # Remove one module
701 701 modules = project.enabled_modules.slice(0..-2)
702 702 assert modules.any?
703 703 assert_difference 'EnabledModule.count', -1 do
704 704 project.enabled_module_names = modules.collect(&:name)
705 705 end
706 706 project.reload
707 707 # Ids should be preserved
708 708 assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort
709 709 end
710 710
711 711 def test_copy_from_existing_project
712 712 source_project = Project.find(1)
713 713 copied_project = Project.copy_from(1)
714 714
715 715 assert copied_project
716 716 # Cleared attributes
717 717 assert copied_project.id.blank?
718 718 assert copied_project.name.blank?
719 719 assert copied_project.identifier.blank?
720 720
721 721 # Duplicated attributes
722 722 assert_equal source_project.description, copied_project.description
723 723 assert_equal source_project.enabled_modules, copied_project.enabled_modules
724 724 assert_equal source_project.trackers, copied_project.trackers
725 725
726 726 # Default attributes
727 727 assert_equal 1, copied_project.status
728 728 end
729 729
730 730 def test_activities_should_use_the_system_activities
731 731 project = Project.find(1)
732 732 assert_equal project.activities, TimeEntryActivity.where(:active => true).all
733 733 end
734 734
735 735
736 736 def test_activities_should_use_the_project_specific_activities
737 737 project = Project.find(1)
738 738 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})
739 739 assert overridden_activity.save!
740 740
741 741 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
742 742 end
743 743
744 744 def test_activities_should_not_include_the_inactive_project_specific_activities
745 745 project = Project.find(1)
746 746 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.first, :active => false})
747 747 assert overridden_activity.save!
748 748
749 749 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"
750 750 end
751 751
752 752 def test_activities_should_not_include_project_specific_activities_from_other_projects
753 753 project = Project.find(1)
754 754 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})
755 755 assert overridden_activity.save!
756 756
757 757 assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"
758 758 end
759 759
760 760 def test_activities_should_handle_nils
761 761 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.first})
762 762 TimeEntryActivity.delete_all
763 763
764 764 # No activities
765 765 project = Project.find(1)
766 766 assert project.activities.empty?
767 767
768 768 # No system, one overridden
769 769 assert overridden_activity.save!
770 770 project.reload
771 771 assert_equal [overridden_activity], project.activities
772 772 end
773 773
774 774 def test_activities_should_override_system_activities_with_project_activities
775 775 project = Project.find(1)
776 776 parent_activity = TimeEntryActivity.first
777 777 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})
778 778 assert overridden_activity.save!
779 779
780 780 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
781 781 assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"
782 782 end
783 783
784 784 def test_activities_should_include_inactive_activities_if_specified
785 785 project = Project.find(1)
786 786 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.first, :active => false})
787 787 assert overridden_activity.save!
788 788
789 789 assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"
790 790 end
791 791
792 792 test 'activities should not include active System activities if the project has an override that is inactive' do
793 793 project = Project.find(1)
794 794 system_activity = TimeEntryActivity.find_by_name('Design')
795 795 assert system_activity.active?
796 796 overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)
797 797 assert overridden_activity.save!
798 798
799 799 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
800 800 assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"
801 801 end
802 802
803 803 def test_close_completed_versions
804 804 Version.update_all("status = 'open'")
805 805 project = Project.find(1)
806 806 assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}
807 807 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
808 808 project.close_completed_versions
809 809 project.reload
810 810 assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}
811 811 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
812 812 end
813 813
814 814 test "#start_date should be nil if there are no issues on the project" do
815 815 project = Project.generate!
816 816 assert_nil project.start_date
817 817 end
818 818
819 819 test "#start_date should be nil when issues have no start date" do
820 820 project = Project.generate!
821 821 project.trackers << Tracker.generate!
822 822 early = 7.days.ago.to_date
823 823 Issue.generate!(:project => project, :start_date => nil)
824 824
825 825 assert_nil project.start_date
826 826 end
827 827
828 828 test "#start_date should be the earliest start date of it's issues" do
829 829 project = Project.generate!
830 830 project.trackers << Tracker.generate!
831 831 early = 7.days.ago.to_date
832 832 Issue.generate!(:project => project, :start_date => Date.today)
833 833 Issue.generate!(:project => project, :start_date => early)
834 834
835 835 assert_equal early, project.start_date
836 836 end
837 837
838 838 test "#due_date should be nil if there are no issues on the project" do
839 839 project = Project.generate!
840 840 assert_nil project.due_date
841 841 end
842 842
843 843 test "#due_date should be nil if there are no issues with due dates" do
844 844 project = Project.generate!
845 845 project.trackers << Tracker.generate!
846 846 Issue.generate!(:project => project, :due_date => nil)
847 847
848 848 assert_nil project.due_date
849 849 end
850 850
851 851 test "#due_date should be the latest due date of it's issues" do
852 852 project = Project.generate!
853 853 project.trackers << Tracker.generate!
854 854 future = 7.days.from_now.to_date
855 855 Issue.generate!(:project => project, :due_date => future)
856 856 Issue.generate!(:project => project, :due_date => Date.today)
857 857
858 858 assert_equal future, project.due_date
859 859 end
860 860
861 861 test "#due_date should be the latest due date of it's versions" do
862 862 project = Project.generate!
863 863 future = 7.days.from_now.to_date
864 864 project.versions << Version.generate!(:effective_date => future)
865 865 project.versions << Version.generate!(:effective_date => Date.today)
866 866
867 867 assert_equal future, project.due_date
868 868 end
869 869
870 870 test "#due_date should pick the latest date from it's issues and versions" do
871 871 project = Project.generate!
872 872 project.trackers << Tracker.generate!
873 873 future = 7.days.from_now.to_date
874 874 far_future = 14.days.from_now.to_date
875 875 Issue.generate!(:project => project, :due_date => far_future)
876 876 project.versions << Version.generate!(:effective_date => future)
877 877
878 878 assert_equal far_future, project.due_date
879 879 end
880 880
881 881 test "#completed_percent with no versions should be 100" do
882 882 project = Project.generate!
883 883 assert_equal 100, project.completed_percent
884 884 end
885 885
886 886 test "#completed_percent with versions should return 0 if the versions have no issues" do
887 887 project = Project.generate!
888 888 Version.generate!(:project => project)
889 889 Version.generate!(:project => project)
890 890
891 891 assert_equal 0, project.completed_percent
892 892 end
893 893
894 894 test "#completed_percent with versions should return 100 if the version has only closed issues" do
895 895 project = Project.generate!
896 896 project.trackers << Tracker.generate!
897 897 v1 = Version.generate!(:project => project)
898 898 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
899 899 v2 = Version.generate!(:project => project)
900 900 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
901 901
902 902 assert_equal 100, project.completed_percent
903 903 end
904 904
905 905 test "#completed_percent with versions should return the averaged completed percent of the versions (not weighted)" do
906 906 project = Project.generate!
907 907 project.trackers << Tracker.generate!
908 908 v1 = Version.generate!(:project => project)
909 909 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
910 910 v2 = Version.generate!(:project => project)
911 911 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
912 912
913 913 assert_equal 50, project.completed_percent
914 914 end
915 915
916 916 test "#notified_users" do
917 917 project = Project.generate!
918 918 role = Role.generate!
919 919
920 920 user_with_membership_notification = User.generate!(:mail_notification => 'selected')
921 921 Member.create!(:project => project, :roles => [role], :principal => user_with_membership_notification, :mail_notification => true)
922 922
923 923 all_events_user = User.generate!(:mail_notification => 'all')
924 924 Member.create!(:project => project, :roles => [role], :principal => all_events_user)
925 925
926 926 no_events_user = User.generate!(:mail_notification => 'none')
927 927 Member.create!(:project => project, :roles => [role], :principal => no_events_user)
928 928
929 929 only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
930 930 Member.create!(:project => project, :roles => [role], :principal => only_my_events_user)
931 931
932 932 only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
933 933 Member.create!(:project => project, :roles => [role], :principal => only_assigned_user)
934 934
935 935 only_owned_user = User.generate!(:mail_notification => 'only_owner')
936 936 Member.create!(:project => project, :roles => [role], :principal => only_owned_user)
937 937
938 938 assert project.notified_users.include?(user_with_membership_notification), "should include members with a mail notification"
939 939 assert project.notified_users.include?(all_events_user), "should include users with the 'all' notification option"
940 940 assert !project.notified_users.include?(no_events_user), "should not include users with the 'none' notification option"
941 941 assert !project.notified_users.include?(only_my_events_user), "should not include users with the 'only_my_events' notification option"
942 942 assert !project.notified_users.include?(only_assigned_user), "should not include users with the 'only_assigned' notification option"
943 943 assert !project.notified_users.include?(only_owned_user), "should not include users with the 'only_owner' notification option"
944 944 end
945 945 end
General Comments 0
You need to be logged in to leave comments. Login now