##// END OF EJS Templates
jro_apps » redmine
RSS
Removed duplicated test....
Jean-Philippe Lang -
r10642:cb24cafedca7
parent child
Show More
Side by Side Unified
Context file:
r10642:cb24cafedca7 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1229 +1,1212
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2012 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 :workflows,
34 34 :versions,
35 35 :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
36 36 :groups_users,
37 37 :boards, :messages,
38 38 :repositories,
39 39 :news, :comments,
40 40 :documents
41 41
42 42 def setup
43 43 @ecookbook = Project.find(1)
44 44 @ecookbook_sub1 = Project.find(3)
45 45 set_tmp_attachments_directory
46 46 User.current = nil
47 47 end
48 48
49 49 def test_truth
50 50 assert_kind_of Project, @ecookbook
51 51 assert_equal "eCookbook", @ecookbook.name
52 52 end
53 53
54 54 def test_default_attributes
55 55 with_settings :default_projects_public => '1' do
56 56 assert_equal true, Project.new.is_public
57 57 assert_equal false, Project.new(:is_public => false).is_public
58 58 end
59 59
60 60 with_settings :default_projects_public => '0' do
61 61 assert_equal false, Project.new.is_public
62 62 assert_equal true, Project.new(:is_public => true).is_public
63 63 end
64 64
65 65 with_settings :sequential_project_identifiers => '1' do
66 66 assert !Project.new.identifier.blank?
67 67 assert Project.new(:identifier => '').identifier.blank?
68 68 end
69 69
70 70 with_settings :sequential_project_identifiers => '0' do
71 71 assert Project.new.identifier.blank?
72 72 assert !Project.new(:identifier => 'test').blank?
73 73 end
74 74
75 75 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
76 76 assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names
77 77 end
78 78
79 79 assert_equal Tracker.all.sort, Project.new.trackers.sort
80 80 assert_equal Tracker.find(1, 3).sort, Project.new(:tracker_ids => [1, 3]).trackers.sort
81 81 end
82 82
83 83 def test_update
84 84 assert_equal "eCookbook", @ecookbook.name
85 85 @ecookbook.name = "eCook"
86 86 assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
87 87 @ecookbook.reload
88 88 assert_equal "eCook", @ecookbook.name
89 89 end
90 90
91 91 def test_validate_identifier
92 92 to_test = {"abc" => true,
93 93 "ab12" => true,
94 94 "ab-12" => true,
95 95 "ab_12" => true,
96 96 "12" => false,
97 97 "new" => false}
98 98
99 99 to_test.each do |identifier, valid|
100 100 p = Project.new
101 101 p.identifier = identifier
102 102 p.valid?
103 103 if valid
104 104 assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"
105 105 else
106 106 assert p.errors['identifier'].present?, "identifier #{identifier} was valid"
107 107 end
108 108 end
109 109 end
110 110
111 111 def test_identifier_should_not_be_frozen_for_a_new_project
112 112 assert_equal false, Project.new.identifier_frozen?
113 113 end
114 114
115 115 def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier
116 116 Project.update_all(["identifier = ''"], "id = 1")
117 117
118 118 assert_equal false, Project.find(1).identifier_frozen?
119 119 end
120 120
121 121 def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier
122 122 assert_equal true, Project.find(1).identifier_frozen?
123 123 end
124 124
125 125 def test_members_should_be_active_users
126 126 Project.all.each do |project|
127 127 assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }
128 128 end
129 129 end
130 130
131 131 def test_users_should_be_active_users
132 132 Project.all.each do |project|
133 133 assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }
134 134 end
135 135 end
136 136
137 137 def test_open_scope_on_issues_association
138 138 assert_kind_of Issue, Project.find(1).issues.open.first
139 139 end
140 140
141 141 def test_archive
142 142 user = @ecookbook.members.first.user
143 143 @ecookbook.archive
144 144 @ecookbook.reload
145 145
146 146 assert !@ecookbook.active?
147 147 assert @ecookbook.archived?
148 148 assert !user.projects.include?(@ecookbook)
149 149 # Subproject are also archived
150 150 assert !@ecookbook.children.empty?
151 151 assert @ecookbook.descendants.active.empty?
152 152 end
153 153
154 154 def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects
155 155 # Assign an issue of a project to a version of a child project
156 156 Issue.find(4).update_attribute :fixed_version_id, 4
157 157
158 158 assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do
159 159 assert_equal false, @ecookbook.archive
160 160 end
161 161 @ecookbook.reload
162 162 assert @ecookbook.active?
163 163 end
164 164
165 165 def test_unarchive
166 166 user = @ecookbook.members.first.user
167 167 @ecookbook.archive
168 168 # A subproject of an archived project can not be unarchived
169 169 assert !@ecookbook_sub1.unarchive
170 170
171 171 # Unarchive project
172 172 assert @ecookbook.unarchive
173 173 @ecookbook.reload
174 174 assert @ecookbook.active?
175 175 assert !@ecookbook.archived?
176 176 assert user.projects.include?(@ecookbook)
177 177 # Subproject can now be unarchived
178 178 @ecookbook_sub1.reload
179 179 assert @ecookbook_sub1.unarchive
180 180 end
181 181
182 182 def test_destroy
183 183 # 2 active members
184 184 assert_equal 2, @ecookbook.members.size
185 185 # and 1 is locked
186 186 assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size
187 187 # some boards
188 188 assert @ecookbook.boards.any?
189 189
190 190 @ecookbook.destroy
191 191 # make sure that the project non longer exists
192 192 assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
193 193 # make sure related data was removed
194 194 assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})
195 195 assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})
196 196 assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})
197 197 end
198 198
199 199 def test_destroy_should_destroy_subtasks
200 200 issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}
201 201 issues[0].update_attribute :parent_issue_id, issues[1].id
202 202 issues[2].update_attribute :parent_issue_id, issues[1].id
203 203 assert_equal 2, issues[1].children.count
204 204
205 205 assert_nothing_raised do
206 206 Project.find(1).destroy
207 207 end
208 208 assert Issue.find_all_by_id(issues.map(&:id)).empty?
209 209 end
210 210
211 211 def test_destroying_root_projects_should_clear_data
212 212 Project.roots.each do |root|
213 213 root.destroy
214 214 end
215 215
216 216 assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"
217 217 assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"
218 218 assert_equal 0, MemberRole.count
219 219 assert_equal 0, Issue.count
220 220 assert_equal 0, Journal.count
221 221 assert_equal 0, JournalDetail.count
222 222 assert_equal 0, Attachment.count, "Attachments were not deleted: #{Attachment.all.inspect}"
223 223 assert_equal 0, EnabledModule.count
224 224 assert_equal 0, IssueCategory.count
225 225 assert_equal 0, IssueRelation.count
226 226 assert_equal 0, Board.count
227 227 assert_equal 0, Message.count
228 228 assert_equal 0, News.count
229 229 assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")
230 230 assert_equal 0, Repository.count
231 231 assert_equal 0, Changeset.count
232 232 assert_equal 0, Change.count
233 233 assert_equal 0, Comment.count
234 234 assert_equal 0, TimeEntry.count
235 235 assert_equal 0, Version.count
236 236 assert_equal 0, Watcher.count
237 237 assert_equal 0, Wiki.count
238 238 assert_equal 0, WikiPage.count
239 239 assert_equal 0, WikiContent.count
240 240 assert_equal 0, WikiContent::Version.count
241 241 assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size
242 242 assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size
243 243 assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})
244 244 end
245 245
246 246 def test_move_an_orphan_project_to_a_root_project
247 247 sub = Project.find(2)
248 248 sub.set_parent! @ecookbook
249 249 assert_equal @ecookbook.id, sub.parent.id
250 250 @ecookbook.reload
251 251 assert_equal 4, @ecookbook.children.size
252 252 end
253 253
254 254 def test_move_an_orphan_project_to_a_subproject
255 255 sub = Project.find(2)
256 256 assert sub.set_parent!(@ecookbook_sub1)
257 257 end
258 258
259 259 def test_move_a_root_project_to_a_project
260 260 sub = @ecookbook
261 261 assert sub.set_parent!(Project.find(2))
262 262 end
263 263
264 264 def test_should_not_move_a_project_to_its_children
265 265 sub = @ecookbook
266 266 assert !(sub.set_parent!(Project.find(3)))
267 267 end
268 268
269 269 def test_set_parent_should_add_roots_in_alphabetical_order
270 270 ProjectCustomField.delete_all
271 271 Project.delete_all
272 272 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
273 273 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
274 274 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
275 275 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
276 276
277 277 assert_equal 4, Project.count
278 278 assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
279 279 end
280 280
281 281 def test_set_parent_should_add_children_in_alphabetical_order
282 282 ProjectCustomField.delete_all
283 283 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
284 284 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
285 285 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
286 286 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
287 287 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
288 288
289 289 parent.reload
290 290 assert_equal 4, parent.children.size
291 291 assert_equal parent.children.all.sort_by(&:name), parent.children.all
292 292 end
293 293
294 def test_rebuild_should_sort_children_alphabetically
295 ProjectCustomField.delete_all
296 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
297 Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)
298 Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)
299 Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)
300 Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)
301
302 Project.update_all("lft = NULL, rgt = NULL")
303 Project.rebuild!
304
305 parent.reload
306 assert_equal 4, parent.children.size
307 assert_equal parent.children.all.sort_by(&:name), parent.children.all
308 end
309
310
311 294 def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy
312 295 # Parent issue with a hierarchy project's fixed version
313 296 parent_issue = Issue.find(1)
314 297 parent_issue.update_attribute(:fixed_version_id, 4)
315 298 parent_issue.reload
316 299 assert_equal 4, parent_issue.fixed_version_id
317 300
318 301 # Should keep fixed versions for the issues
319 302 issue_with_local_fixed_version = Issue.find(5)
320 303 issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)
321 304 issue_with_local_fixed_version.reload
322 305 assert_equal 4, issue_with_local_fixed_version.fixed_version_id
323 306
324 307 # Local issue with hierarchy fixed_version
325 308 issue_with_hierarchy_fixed_version = Issue.find(13)
326 309 issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)
327 310 issue_with_hierarchy_fixed_version.reload
328 311 assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id
329 312
330 313 # Move project out of the issue's hierarchy
331 314 moved_project = Project.find(3)
332 315 moved_project.set_parent!(Project.find(2))
333 316 parent_issue.reload
334 317 issue_with_local_fixed_version.reload
335 318 issue_with_hierarchy_fixed_version.reload
336 319
337 320 assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"
338 321 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"
339 322 assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."
340 323 end
341 324
342 325 def test_parent
343 326 p = Project.find(6).parent
344 327 assert p.is_a?(Project)
345 328 assert_equal 5, p.id
346 329 end
347 330
348 331 def test_ancestors
349 332 a = Project.find(6).ancestors
350 333 assert a.first.is_a?(Project)
351 334 assert_equal [1, 5], a.collect(&:id)
352 335 end
353 336
354 337 def test_root
355 338 r = Project.find(6).root
356 339 assert r.is_a?(Project)
357 340 assert_equal 1, r.id
358 341 end
359 342
360 343 def test_children
361 344 c = Project.find(1).children
362 345 assert c.first.is_a?(Project)
363 346 assert_equal [5, 3, 4], c.collect(&:id)
364 347 end
365 348
366 349 def test_descendants
367 350 d = Project.find(1).descendants
368 351 assert d.first.is_a?(Project)
369 352 assert_equal [5, 6, 3, 4], d.collect(&:id)
370 353 end
371 354
372 355 def test_allowed_parents_should_be_empty_for_non_member_user
373 356 Role.non_member.add_permission!(:add_project)
374 357 user = User.find(9)
375 358 assert user.memberships.empty?
376 359 User.current = user
377 360 assert Project.new.allowed_parents.compact.empty?
378 361 end
379 362
380 363 def test_allowed_parents_with_add_subprojects_permission
381 364 Role.find(1).remove_permission!(:add_project)
382 365 Role.find(1).add_permission!(:add_subprojects)
383 366 User.current = User.find(2)
384 367 # new project
385 368 assert !Project.new.allowed_parents.include?(nil)
386 369 assert Project.new.allowed_parents.include?(Project.find(1))
387 370 # existing root project
388 371 assert Project.find(1).allowed_parents.include?(nil)
389 372 # existing child
390 373 assert Project.find(3).allowed_parents.include?(Project.find(1))
391 374 assert !Project.find(3).allowed_parents.include?(nil)
392 375 end
393 376
394 377 def test_allowed_parents_with_add_project_permission
395 378 Role.find(1).add_permission!(:add_project)
396 379 Role.find(1).remove_permission!(:add_subprojects)
397 380 User.current = User.find(2)
398 381 # new project
399 382 assert Project.new.allowed_parents.include?(nil)
400 383 assert !Project.new.allowed_parents.include?(Project.find(1))
401 384 # existing root project
402 385 assert Project.find(1).allowed_parents.include?(nil)
403 386 # existing child
404 387 assert Project.find(3).allowed_parents.include?(Project.find(1))
405 388 assert Project.find(3).allowed_parents.include?(nil)
406 389 end
407 390
408 391 def test_allowed_parents_with_add_project_and_subprojects_permission
409 392 Role.find(1).add_permission!(:add_project)
410 393 Role.find(1).add_permission!(:add_subprojects)
411 394 User.current = User.find(2)
412 395 # new project
413 396 assert Project.new.allowed_parents.include?(nil)
414 397 assert Project.new.allowed_parents.include?(Project.find(1))
415 398 # existing root project
416 399 assert Project.find(1).allowed_parents.include?(nil)
417 400 # existing child
418 401 assert Project.find(3).allowed_parents.include?(Project.find(1))
419 402 assert Project.find(3).allowed_parents.include?(nil)
420 403 end
421 404
422 405 def test_users_by_role
423 406 users_by_role = Project.find(1).users_by_role
424 407 assert_kind_of Hash, users_by_role
425 408 role = Role.find(1)
426 409 assert_kind_of Array, users_by_role[role]
427 410 assert users_by_role[role].include?(User.find(2))
428 411 end
429 412
430 413 def test_rolled_up_trackers
431 414 parent = Project.find(1)
432 415 parent.trackers = Tracker.find([1,2])
433 416 child = parent.children.find(3)
434 417
435 418 assert_equal [1, 2], parent.tracker_ids
436 419 assert_equal [2, 3], child.trackers.collect(&:id)
437 420
438 421 assert_kind_of Tracker, parent.rolled_up_trackers.first
439 422 assert_equal Tracker.find(1), parent.rolled_up_trackers.first
440 423
441 424 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
442 425 assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
443 426 end
444 427
445 428 def test_rolled_up_trackers_should_ignore_archived_subprojects
446 429 parent = Project.find(1)
447 430 parent.trackers = Tracker.find([1,2])
448 431 child = parent.children.find(3)
449 432 child.trackers = Tracker.find([1,3])
450 433 parent.children.each(&:archive)
451 434
452 435 assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)
453 436 end
454 437
455 438 context "#rolled_up_versions" do
456 439 setup do
457 440 @project = Project.generate!
458 441 @parent_version_1 = Version.generate!(:project => @project)
459 442 @parent_version_2 = Version.generate!(:project => @project)
460 443 end
461 444
462 445 should "include the versions for the current project" do
463 446 assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
464 447 end
465 448
466 449 should "include versions for a subproject" do
467 450 @subproject = Project.generate!
468 451 @subproject.set_parent!(@project)
469 452 @subproject_version = Version.generate!(:project => @subproject)
470 453
471 454 assert_same_elements [
472 455 @parent_version_1,
473 456 @parent_version_2,
474 457 @subproject_version
475 458 ], @project.rolled_up_versions
476 459 end
477 460
478 461 should "include versions for a sub-subproject" do
479 462 @subproject = Project.generate!
480 463 @subproject.set_parent!(@project)
481 464 @sub_subproject = Project.generate!
482 465 @sub_subproject.set_parent!(@subproject)
483 466 @sub_subproject_version = Version.generate!(:project => @sub_subproject)
484 467
485 468 @project.reload
486 469
487 470 assert_same_elements [
488 471 @parent_version_1,
489 472 @parent_version_2,
490 473 @sub_subproject_version
491 474 ], @project.rolled_up_versions
492 475 end
493 476
494 477 should "only check active projects" do
495 478 @subproject = Project.generate!
496 479 @subproject.set_parent!(@project)
497 480 @subproject_version = Version.generate!(:project => @subproject)
498 481 assert @subproject.archive
499 482
500 483 @project.reload
501 484
502 485 assert !@subproject.active?
503 486 assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
504 487 end
505 488 end
506 489
507 490 def test_shared_versions_none_sharing
508 491 p = Project.find(5)
509 492 v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')
510 493 assert p.shared_versions.include?(v)
511 494 assert !p.children.first.shared_versions.include?(v)
512 495 assert !p.root.shared_versions.include?(v)
513 496 assert !p.siblings.first.shared_versions.include?(v)
514 497 assert !p.root.siblings.first.shared_versions.include?(v)
515 498 end
516 499
517 500 def test_shared_versions_descendants_sharing
518 501 p = Project.find(5)
519 502 v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')
520 503 assert p.shared_versions.include?(v)
521 504 assert p.children.first.shared_versions.include?(v)
522 505 assert !p.root.shared_versions.include?(v)
523 506 assert !p.siblings.first.shared_versions.include?(v)
524 507 assert !p.root.siblings.first.shared_versions.include?(v)
525 508 end
526 509
527 510 def test_shared_versions_hierarchy_sharing
528 511 p = Project.find(5)
529 512 v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')
530 513 assert p.shared_versions.include?(v)
531 514 assert p.children.first.shared_versions.include?(v)
532 515 assert p.root.shared_versions.include?(v)
533 516 assert !p.siblings.first.shared_versions.include?(v)
534 517 assert !p.root.siblings.first.shared_versions.include?(v)
535 518 end
536 519
537 520 def test_shared_versions_tree_sharing
538 521 p = Project.find(5)
539 522 v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')
540 523 assert p.shared_versions.include?(v)
541 524 assert p.children.first.shared_versions.include?(v)
542 525 assert p.root.shared_versions.include?(v)
543 526 assert p.siblings.first.shared_versions.include?(v)
544 527 assert !p.root.siblings.first.shared_versions.include?(v)
545 528 end
546 529
547 530 def test_shared_versions_system_sharing
548 531 p = Project.find(5)
549 532 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
550 533 assert p.shared_versions.include?(v)
551 534 assert p.children.first.shared_versions.include?(v)
552 535 assert p.root.shared_versions.include?(v)
553 536 assert p.siblings.first.shared_versions.include?(v)
554 537 assert p.root.siblings.first.shared_versions.include?(v)
555 538 end
556 539
557 540 def test_shared_versions
558 541 parent = Project.find(1)
559 542 child = parent.children.find(3)
560 543 private_child = parent.children.find(5)
561 544
562 545 assert_equal [1,2,3], parent.version_ids.sort
563 546 assert_equal [4], child.version_ids
564 547 assert_equal [6], private_child.version_ids
565 548 assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)
566 549
567 550 assert_equal 6, parent.shared_versions.size
568 551 parent.shared_versions.each do |version|
569 552 assert_kind_of Version, version
570 553 end
571 554
572 555 assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort
573 556 end
574 557
575 558 def test_shared_versions_should_ignore_archived_subprojects
576 559 parent = Project.find(1)
577 560 child = parent.children.find(3)
578 561 child.archive
579 562 parent.reload
580 563
581 564 assert_equal [1,2,3], parent.version_ids.sort
582 565 assert_equal [4], child.version_ids
583 566 assert !parent.shared_versions.collect(&:id).include?(4)
584 567 end
585 568
586 569 def test_shared_versions_visible_to_user
587 570 user = User.find(3)
588 571 parent = Project.find(1)
589 572 child = parent.children.find(5)
590 573
591 574 assert_equal [1,2,3], parent.version_ids.sort
592 575 assert_equal [6], child.version_ids
593 576
594 577 versions = parent.shared_versions.visible(user)
595 578
596 579 assert_equal 4, versions.size
597 580 versions.each do |version|
598 581 assert_kind_of Version, version
599 582 end
600 583
601 584 assert !versions.collect(&:id).include?(6)
602 585 end
603 586
604 587 def test_shared_versions_for_new_project_should_include_system_shared_versions
605 588 p = Project.find(5)
606 589 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
607 590
608 591 assert_include v, Project.new.shared_versions
609 592 end
610 593
611 594 def test_next_identifier
612 595 ProjectCustomField.delete_all
613 596 Project.create!(:name => 'last', :identifier => 'p2008040')
614 597 assert_equal 'p2008041', Project.next_identifier
615 598 end
616 599
617 600 def test_next_identifier_first_project
618 601 Project.delete_all
619 602 assert_nil Project.next_identifier
620 603 end
621 604
622 605 def test_enabled_module_names
623 606 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
624 607 project = Project.new
625 608
626 609 project.enabled_module_names = %w(issue_tracking news)
627 610 assert_equal %w(issue_tracking news), project.enabled_module_names.sort
628 611 end
629 612 end
630 613
631 614 context "enabled_modules" do
632 615 setup do
633 616 @project = Project.find(1)
634 617 end
635 618
636 619 should "define module by names and preserve ids" do
637 620 # Remove one module
638 621 modules = @project.enabled_modules.slice(0..-2)
639 622 assert modules.any?
640 623 assert_difference 'EnabledModule.count', -1 do
641 624 @project.enabled_module_names = modules.collect(&:name)
642 625 end
643 626 @project.reload
644 627 # Ids should be preserved
645 628 assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
646 629 end
647 630
648 631 should "enable a module" do
649 632 @project.enabled_module_names = []
650 633 @project.reload
651 634 assert_equal [], @project.enabled_module_names
652 635 #with string
653 636 @project.enable_module!("issue_tracking")
654 637 assert_equal ["issue_tracking"], @project.enabled_module_names
655 638 #with symbol
656 639 @project.enable_module!(:gantt)
657 640 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
658 641 #don't add a module twice
659 642 @project.enable_module!("issue_tracking")
660 643 assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
661 644 end
662 645
663 646 should "disable a module" do
664 647 #with string
665 648 assert @project.enabled_module_names.include?("issue_tracking")
666 649 @project.disable_module!("issue_tracking")
667 650 assert ! @project.reload.enabled_module_names.include?("issue_tracking")
668 651 #with symbol
669 652 assert @project.enabled_module_names.include?("gantt")
670 653 @project.disable_module!(:gantt)
671 654 assert ! @project.reload.enabled_module_names.include?("gantt")
672 655 #with EnabledModule object
673 656 first_module = @project.enabled_modules.first
674 657 @project.disable_module!(first_module)
675 658 assert ! @project.reload.enabled_module_names.include?(first_module.name)
676 659 end
677 660 end
678 661
679 662 def test_enabled_module_names_should_not_recreate_enabled_modules
680 663 project = Project.find(1)
681 664 # Remove one module
682 665 modules = project.enabled_modules.slice(0..-2)
683 666 assert modules.any?
684 667 assert_difference 'EnabledModule.count', -1 do
685 668 project.enabled_module_names = modules.collect(&:name)
686 669 end
687 670 project.reload
688 671 # Ids should be preserved
689 672 assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort
690 673 end
691 674
692 675 def test_copy_from_existing_project
693 676 source_project = Project.find(1)
694 677 copied_project = Project.copy_from(1)
695 678
696 679 assert copied_project
697 680 # Cleared attributes
698 681 assert copied_project.id.blank?
699 682 assert copied_project.name.blank?
700 683 assert copied_project.identifier.blank?
701 684
702 685 # Duplicated attributes
703 686 assert_equal source_project.description, copied_project.description
704 687 assert_equal source_project.enabled_modules, copied_project.enabled_modules
705 688 assert_equal source_project.trackers, copied_project.trackers
706 689
707 690 # Default attributes
708 691 assert_equal 1, copied_project.status
709 692 end
710 693
711 694 def test_activities_should_use_the_system_activities
712 695 project = Project.find(1)
713 696 assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )
714 697 end
715 698
716 699
717 700 def test_activities_should_use_the_project_specific_activities
718 701 project = Project.find(1)
719 702 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})
720 703 assert overridden_activity.save!
721 704
722 705 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
723 706 end
724 707
725 708 def test_activities_should_not_include_the_inactive_project_specific_activities
726 709 project = Project.find(1)
727 710 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
728 711 assert overridden_activity.save!
729 712
730 713 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"
731 714 end
732 715
733 716 def test_activities_should_not_include_project_specific_activities_from_other_projects
734 717 project = Project.find(1)
735 718 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})
736 719 assert overridden_activity.save!
737 720
738 721 assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"
739 722 end
740 723
741 724 def test_activities_should_handle_nils
742 725 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.find(:first)})
743 726 TimeEntryActivity.delete_all
744 727
745 728 # No activities
746 729 project = Project.find(1)
747 730 assert project.activities.empty?
748 731
749 732 # No system, one overridden
750 733 assert overridden_activity.save!
751 734 project.reload
752 735 assert_equal [overridden_activity], project.activities
753 736 end
754 737
755 738 def test_activities_should_override_system_activities_with_project_activities
756 739 project = Project.find(1)
757 740 parent_activity = TimeEntryActivity.find(:first)
758 741 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})
759 742 assert overridden_activity.save!
760 743
761 744 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
762 745 assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"
763 746 end
764 747
765 748 def test_activities_should_include_inactive_activities_if_specified
766 749 project = Project.find(1)
767 750 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
768 751 assert overridden_activity.save!
769 752
770 753 assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"
771 754 end
772 755
773 756 test 'activities should not include active System activities if the project has an override that is inactive' do
774 757 project = Project.find(1)
775 758 system_activity = TimeEntryActivity.find_by_name('Design')
776 759 assert system_activity.active?
777 760 overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)
778 761 assert overridden_activity.save!
779 762
780 763 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
781 764 assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"
782 765 end
783 766
784 767 def test_close_completed_versions
785 768 Version.update_all("status = 'open'")
786 769 project = Project.find(1)
787 770 assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}
788 771 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
789 772 project.close_completed_versions
790 773 project.reload
791 774 assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}
792 775 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
793 776 end
794 777
795 778 context "Project#copy" do
796 779 setup do
797 780 ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
798 781 Project.destroy_all :identifier => "copy-test"
799 782 @source_project = Project.find(2)
800 783 @project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')
801 784 @project.trackers = @source_project.trackers
802 785 @project.enabled_module_names = @source_project.enabled_modules.collect(&:name)
803 786 end
804 787
805 788 should "copy issues" do
806 789 @source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),
807 790 :subject => "copy issue status",
808 791 :tracker_id => 1,
809 792 :assigned_to_id => 2,
810 793 :project_id => @source_project.id)
811 794 assert @project.valid?
812 795 assert @project.issues.empty?
813 796 assert @project.copy(@source_project)
814 797
815 798 assert_equal @source_project.issues.size, @project.issues.size
816 799 @project.issues.each do |issue|
817 800 assert issue.valid?
818 801 assert ! issue.assigned_to.blank?
819 802 assert_equal @project, issue.project
820 803 end
821 804
822 805 copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})
823 806 assert copied_issue
824 807 assert copied_issue.status
825 808 assert_equal "Closed", copied_issue.status.name
826 809 end
827 810
828 811 should "copy issues assigned to a locked version" do
829 812 User.current = User.find(1)
830 813 assigned_version = Version.generate!(:name => "Assigned Issues")
831 814 @source_project.versions << assigned_version
832 815 Issue.generate!(:project => @source_project,
833 816 :fixed_version_id => assigned_version.id,
834 817 :subject => "copy issues assigned to a locked version")
835 818 assigned_version.update_attribute :status, 'locked'
836 819
837 820 assert @project.copy(@source_project)
838 821 @project.reload
839 822 copied_issue = @project.issues.first(:conditions => {:subject => "copy issues assigned to a locked version"})
840 823
841 824 assert copied_issue
842 825 assert copied_issue.fixed_version
843 826 assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
844 827 assert_equal 'locked', copied_issue.fixed_version.status
845 828 end
846 829
847 830 should "change the new issues to use the copied version" do
848 831 User.current = User.find(1)
849 832 assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')
850 833 @source_project.versions << assigned_version
851 834 assert_equal 3, @source_project.versions.size
852 835 Issue.generate!(:project => @source_project,
853 836 :fixed_version_id => assigned_version.id,
854 837 :subject => "change the new issues to use the copied version")
855 838
856 839 assert @project.copy(@source_project)
857 840 @project.reload
858 841 copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})
859 842
860 843 assert copied_issue
861 844 assert copied_issue.fixed_version
862 845 assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
863 846 assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record
864 847 end
865 848
866 849 should "keep target shared versions from other project" do
867 850 assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open', :project_id => 1, :sharing => 'system')
868 851 issue = Issue.generate!(:project => @source_project,
869 852 :fixed_version => assigned_version,
870 853 :subject => "keep target shared versions")
871 854
872 855 assert @project.copy(@source_project)
873 856 @project.reload
874 857 copied_issue = @project.issues.first(:conditions => {:subject => "keep target shared versions"})
875 858
876 859 assert copied_issue
877 860 assert_equal assigned_version, copied_issue.fixed_version
878 861 end
879 862
880 863 should "copy issue relations" do
881 864 Setting.cross_project_issue_relations = '1'
882 865
883 866 second_issue = Issue.generate!(:status_id => 5,
884 867 :subject => "copy issue relation",
885 868 :tracker_id => 1,
886 869 :assigned_to_id => 2,
887 870 :project_id => @source_project.id)
888 871 source_relation = IssueRelation.create!(:issue_from => Issue.find(4),
889 872 :issue_to => second_issue,
890 873 :relation_type => "relates")
891 874 source_relation_cross_project = IssueRelation.create!(:issue_from => Issue.find(1),
892 875 :issue_to => second_issue,
893 876 :relation_type => "duplicates")
894 877
895 878 assert @project.copy(@source_project)
896 879 assert_equal @source_project.issues.count, @project.issues.count
897 880 copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4
898 881 copied_second_issue = @project.issues.find_by_subject("copy issue relation")
899 882
900 883 # First issue with a relation on project
901 884 assert_equal 1, copied_issue.relations.size, "Relation not copied"
902 885 copied_relation = copied_issue.relations.first
903 886 assert_equal "relates", copied_relation.relation_type
904 887 assert_equal copied_second_issue.id, copied_relation.issue_to_id
905 888 assert_not_equal source_relation.id, copied_relation.id
906 889
907 890 # Second issue with a cross project relation
908 891 assert_equal 2, copied_second_issue.relations.size, "Relation not copied"
909 892 copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first
910 893 assert_equal "duplicates", copied_relation.relation_type
911 894 assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"
912 895 assert_not_equal source_relation_cross_project.id, copied_relation.id
913 896 end
914 897
915 898 should "copy issue attachments" do
916 899 issue = Issue.generate!(:subject => "copy with attachment", :tracker_id => 1, :project_id => @source_project.id)
917 900 Attachment.create!(:container => issue, :file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 1)
918 901 @source_project.issues << issue
919 902 assert @project.copy(@source_project)
920 903
921 904 copied_issue = @project.issues.first(:conditions => {:subject => "copy with attachment"})
922 905 assert_not_nil copied_issue
923 906 assert_equal 1, copied_issue.attachments.count, "Attachment not copied"
924 907 assert_equal "testfile.txt", copied_issue.attachments.first.filename
925 908 end
926 909
927 910 should "copy memberships" do
928 911 assert @project.valid?
929 912 assert @project.members.empty?
930 913 assert @project.copy(@source_project)
931 914
932 915 assert_equal @source_project.memberships.size, @project.memberships.size
933 916 @project.memberships.each do |membership|
934 917 assert membership
935 918 assert_equal @project, membership.project
936 919 end
937 920 end
938 921
939 922 should "copy memberships with groups and additional roles" do
940 923 group = Group.create!(:lastname => "Copy group")
941 924 user = User.find(7)
942 925 group.users << user
943 926 # group role
944 927 Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])
945 928 member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)
946 929 # additional role
947 930 member.role_ids = [1]
948 931
949 932 assert @project.copy(@source_project)
950 933 member = Member.find_by_user_id_and_project_id(user.id, @project.id)
951 934 assert_not_nil member
952 935 assert_equal [1, 2], member.role_ids.sort
953 936 end
954 937
955 938 should "copy project specific queries" do
956 939 assert @project.valid?
957 940 assert @project.queries.empty?
958 941 assert @project.copy(@source_project)
959 942
960 943 assert_equal @source_project.queries.size, @project.queries.size
961 944 @project.queries.each do |query|
962 945 assert query
963 946 assert_equal @project, query.project
964 947 end
965 948 assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort
966 949 end
967 950
968 951 should "copy versions" do
969 952 @source_project.versions << Version.generate!
970 953 @source_project.versions << Version.generate!
971 954
972 955 assert @project.versions.empty?
973 956 assert @project.copy(@source_project)
974 957
975 958 assert_equal @source_project.versions.size, @project.versions.size
976 959 @project.versions.each do |version|
977 960 assert version
978 961 assert_equal @project, version.project
979 962 end
980 963 end
981 964
982 965 should "copy wiki" do
983 966 assert_difference 'Wiki.count' do
984 967 assert @project.copy(@source_project)
985 968 end
986 969
987 970 assert @project.wiki
988 971 assert_not_equal @source_project.wiki, @project.wiki
989 972 assert_equal "Start page", @project.wiki.start_page
990 973 end
991 974
992 975 should "copy wiki pages and content with hierarchy" do
993 976 assert_difference 'WikiPage.count', @source_project.wiki.pages.size do
994 977 assert @project.copy(@source_project)
995 978 end
996 979
997 980 assert @project.wiki
998 981 assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size
999 982
1000 983 @project.wiki.pages.each do |wiki_page|
1001 984 assert wiki_page.content
1002 985 assert !@source_project.wiki.pages.include?(wiki_page)
1003 986 end
1004 987
1005 988 parent = @project.wiki.find_page('Parent_page')
1006 989 child1 = @project.wiki.find_page('Child_page_1')
1007 990 child2 = @project.wiki.find_page('Child_page_2')
1008 991 assert_equal parent, child1.parent
1009 992 assert_equal parent, child2.parent
1010 993 end
1011 994
1012 995 should "copy issue categories" do
1013 996 assert @project.copy(@source_project)
1014 997
1015 998 assert_equal 2, @project.issue_categories.size
1016 999 @project.issue_categories.each do |issue_category|
1017 1000 assert !@source_project.issue_categories.include?(issue_category)
1018 1001 end
1019 1002 end
1020 1003
1021 1004 should "copy boards" do
1022 1005 assert @project.copy(@source_project)
1023 1006
1024 1007 assert_equal 1, @project.boards.size
1025 1008 @project.boards.each do |board|
1026 1009 assert !@source_project.boards.include?(board)
1027 1010 end
1028 1011 end
1029 1012
1030 1013 should "change the new issues to use the copied issue categories" do
1031 1014 issue = Issue.find(4)
1032 1015 issue.update_attribute(:category_id, 3)
1033 1016
1034 1017 assert @project.copy(@source_project)
1035 1018
1036 1019 @project.issues.each do |issue|
1037 1020 assert issue.category
1038 1021 assert_equal "Stock management", issue.category.name # Same name
1039 1022 assert_not_equal IssueCategory.find(3), issue.category # Different record
1040 1023 end
1041 1024 end
1042 1025
1043 1026 should "limit copy with :only option" do
1044 1027 assert @project.members.empty?
1045 1028 assert @project.issue_categories.empty?
1046 1029 assert @source_project.issues.any?
1047 1030
1048 1031 assert @project.copy(@source_project, :only => ['members', 'issue_categories'])
1049 1032
1050 1033 assert @project.members.any?
1051 1034 assert @project.issue_categories.any?
1052 1035 assert @project.issues.empty?
1053 1036 end
1054 1037 end
1055 1038
1056 1039 def test_copy_should_copy_subtasks
1057 1040 source = Project.generate!(:tracker_ids => [1])
1058 1041 issue = Issue.generate_with_descendants!(:project => source)
1059 1042 project = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1])
1060 1043
1061 1044 assert_difference 'Project.count' do
1062 1045 assert_difference 'Issue.count', 1+issue.descendants.count do
1063 1046 assert project.copy(source.reload)
1064 1047 end
1065 1048 end
1066 1049 copy = Issue.where(:parent_id => nil).order("id DESC").first
1067 1050 assert_equal project, copy.project
1068 1051 assert_equal issue.descendants.count, copy.descendants.count
1069 1052 child_copy = copy.children.detect {|c| c.subject == 'Child1'}
1070 1053 assert child_copy.descendants.any?
1071 1054 end
1072 1055
1073 1056 context "#start_date" do
1074 1057 setup do
1075 1058 ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
1076 1059 @project = Project.generate!(:identifier => 'test0')
1077 1060 @project.trackers << Tracker.generate!
1078 1061 end
1079 1062
1080 1063 should "be nil if there are no issues on the project" do
1081 1064 assert_nil @project.start_date
1082 1065 end
1083 1066
1084 1067 should "be tested when issues have no start date"
1085 1068
1086 1069 should "be the earliest start date of it's issues" do
1087 1070 early = 7.days.ago.to_date
1088 1071 Issue.generate!(:project => @project, :start_date => Date.today)
1089 1072 Issue.generate!(:project => @project, :start_date => early)
1090 1073
1091 1074 assert_equal early, @project.start_date
1092 1075 end
1093 1076
1094 1077 end
1095 1078
1096 1079 context "#due_date" do
1097 1080 setup do
1098 1081 ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
1099 1082 @project = Project.generate!(:identifier => 'test0')
1100 1083 @project.trackers << Tracker.generate!
1101 1084 end
1102 1085
1103 1086 should "be nil if there are no issues on the project" do
1104 1087 assert_nil @project.due_date
1105 1088 end
1106 1089
1107 1090 should "be tested when issues have no due date"
1108 1091
1109 1092 should "be the latest due date of it's issues" do
1110 1093 future = 7.days.from_now.to_date
1111 1094 Issue.generate!(:project => @project, :due_date => future)
1112 1095 Issue.generate!(:project => @project, :due_date => Date.today)
1113 1096
1114 1097 assert_equal future, @project.due_date
1115 1098 end
1116 1099
1117 1100 should "be the latest due date of it's versions" do
1118 1101 future = 7.days.from_now.to_date
1119 1102 @project.versions << Version.generate!(:effective_date => future)
1120 1103 @project.versions << Version.generate!(:effective_date => Date.today)
1121 1104
1122 1105
1123 1106 assert_equal future, @project.due_date
1124 1107
1125 1108 end
1126 1109
1127 1110 should "pick the latest date from it's issues and versions" do
1128 1111 future = 7.days.from_now.to_date
1129 1112 far_future = 14.days.from_now.to_date
1130 1113 Issue.generate!(:project => @project, :due_date => far_future)
1131 1114 @project.versions << Version.generate!(:effective_date => future)
1132 1115
1133 1116 assert_equal far_future, @project.due_date
1134 1117 end
1135 1118
1136 1119 end
1137 1120
1138 1121 context "Project#completed_percent" do
1139 1122 setup do
1140 1123 ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
1141 1124 @project = Project.generate!(:identifier => 'test0')
1142 1125 @project.trackers << Tracker.generate!
1143 1126 end
1144 1127
1145 1128 context "no versions" do
1146 1129 should "be 100" do
1147 1130 assert_equal 100, @project.completed_percent
1148 1131 end
1149 1132 end
1150 1133
1151 1134 context "with versions" do
1152 1135 should "return 0 if the versions have no issues" do
1153 1136 Version.generate!(:project => @project)
1154 1137 Version.generate!(:project => @project)
1155 1138
1156 1139 assert_equal 0, @project.completed_percent
1157 1140 end
1158 1141
1159 1142 should "return 100 if the version has only closed issues" do
1160 1143 v1 = Version.generate!(:project => @project)
1161 1144 Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
1162 1145 v2 = Version.generate!(:project => @project)
1163 1146 Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
1164 1147
1165 1148 assert_equal 100, @project.completed_percent
1166 1149 end
1167 1150
1168 1151 should "return the averaged completed percent of the versions (not weighted)" do
1169 1152 v1 = Version.generate!(:project => @project)
1170 1153 Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
1171 1154 v2 = Version.generate!(:project => @project)
1172 1155 Issue.generate!(:project => @project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
1173 1156
1174 1157 assert_equal 50, @project.completed_percent
1175 1158 end
1176 1159
1177 1160 end
1178 1161 end
1179 1162
1180 1163 context "#notified_users" do
1181 1164 setup do
1182 1165 @project = Project.generate!
1183 1166 @role = Role.generate!
1184 1167
1185 1168 @user_with_membership_notification = User.generate!(:mail_notification => 'selected')
1186 1169 Member.create!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
1187 1170
1188 1171 @all_events_user = User.generate!(:mail_notification => 'all')
1189 1172 Member.create!(:project => @project, :roles => [@role], :principal => @all_events_user)
1190 1173
1191 1174 @no_events_user = User.generate!(:mail_notification => 'none')
1192 1175 Member.create!(:project => @project, :roles => [@role], :principal => @no_events_user)
1193 1176
1194 1177 @only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
1195 1178 Member.create!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
1196 1179
1197 1180 @only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
1198 1181 Member.create!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
1199 1182
1200 1183 @only_owned_user = User.generate!(:mail_notification => 'only_owner')
1201 1184 Member.create!(:project => @project, :roles => [@role], :principal => @only_owned_user)
1202 1185 end
1203 1186
1204 1187 should "include members with a mail notification" do
1205 1188 assert @project.notified_users.include?(@user_with_membership_notification)
1206 1189 end
1207 1190
1208 1191 should "include users with the 'all' notification option" do
1209 1192 assert @project.notified_users.include?(@all_events_user)
1210 1193 end
1211 1194
1212 1195 should "not include users with the 'none' notification option" do
1213 1196 assert !@project.notified_users.include?(@no_events_user)
1214 1197 end
1215 1198
1216 1199 should "not include users with the 'only_my_events' notification option" do
1217 1200 assert !@project.notified_users.include?(@only_my_events_user)
1218 1201 end
1219 1202
1220 1203 should "not include users with the 'only_assigned' notification option" do
1221 1204 assert !@project.notified_users.include?(@only_assigned_user)
1222 1205 end
1223 1206
1224 1207 should "not include users with the 'only_owner' notification option" do
1225 1208 assert !@project.notified_users.include?(@only_owned_user)
1226 1209 end
1227 1210 end
1228 1211
1229 1212 end
General Comments 0
You need to be logged in to leave comments. Login now