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