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