##// END OF EJS Templates
jro_apps » redmine
RSS
remove empty lines including white space from test/unit/user_test.rb...
Toshi MARUYAMA -
r15780:a1c37e7d6cd5
parent child
Show More
Side by Side Unified
Context file:
r15780:a1c37e7d6cd5 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1240 +1,1238
1 # Redmine - project management software
1 # Redmine - project management software
2 # Copyright (C) 2006-2016 Jean-Philippe Lang
2 # Copyright (C) 2006-2016 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 UserTest < ActiveSupport::TestCase
20 class UserTest < ActiveSupport::TestCase
21 fixtures :users, :email_addresses, :members, :projects, :roles, :member_roles, :auth_sources,
21 fixtures :users, :email_addresses, :members, :projects, :roles, :member_roles, :auth_sources,
22 :trackers, :issue_statuses,
22 :trackers, :issue_statuses,
23 :projects_trackers,
23 :projects_trackers,
24 :watchers,
24 :watchers,
25 :issue_categories, :enumerations, :issues,
25 :issue_categories, :enumerations, :issues,
26 :journals, :journal_details,
26 :journals, :journal_details,
27 :groups_users,
27 :groups_users,
28 :enabled_modules,
28 :enabled_modules,
29 :tokens
29 :tokens
30
30
31 include Redmine::I18n
31 include Redmine::I18n
32
32
33 def setup
33 def setup
34 @admin = User.find(1)
34 @admin = User.find(1)
35 @jsmith = User.find(2)
35 @jsmith = User.find(2)
36 @dlopper = User.find(3)
36 @dlopper = User.find(3)
37 end
37 end
38
38
39 def test_sorted_scope_should_sort_user_by_display_name
39 def test_sorted_scope_should_sort_user_by_display_name
40 # Use .active to ignore anonymous with localized display name
40 # Use .active to ignore anonymous with localized display name
41 assert_equal User.active.map(&:name).map(&:downcase).sort,
41 assert_equal User.active.map(&:name).map(&:downcase).sort,
42 User.active.sorted.map(&:name).map(&:downcase)
42 User.active.sorted.map(&:name).map(&:downcase)
43 end
43 end
44
44
45 def test_generate
45 def test_generate
46 User.generate!(:firstname => 'Testing connection')
46 User.generate!(:firstname => 'Testing connection')
47 User.generate!(:firstname => 'Testing connection')
47 User.generate!(:firstname => 'Testing connection')
48 assert_equal 2, User.where(:firstname => 'Testing connection').count
48 assert_equal 2, User.where(:firstname => 'Testing connection').count
49 end
49 end
50
50
51 def test_truth
51 def test_truth
52 assert_kind_of User, @jsmith
52 assert_kind_of User, @jsmith
53 end
53 end
54
54
55 def test_should_validate_status
55 def test_should_validate_status
56 user = User.new
56 user = User.new
57 user.status = 0
57 user.status = 0
58
58
59 assert !user.save
59 assert !user.save
60 assert_include I18n.translate('activerecord.errors.messages.invalid'), user.errors[:status]
60 assert_include I18n.translate('activerecord.errors.messages.invalid'), user.errors[:status]
61 end
61 end
62
62
63 def test_mail_should_be_stripped
63 def test_mail_should_be_stripped
64 u = User.new
64 u = User.new
65 u.mail = " foo@bar.com "
65 u.mail = " foo@bar.com "
66 assert_equal "foo@bar.com", u.mail
66 assert_equal "foo@bar.com", u.mail
67 end
67 end
68
68
69 def test_should_create_email_address
69 def test_should_create_email_address
70 u = User.new(:firstname => "new", :lastname => "user")
70 u = User.new(:firstname => "new", :lastname => "user")
71 u.login = "create_email_address"
71 u.login = "create_email_address"
72 u.mail = "defaultemail@somenet.foo"
72 u.mail = "defaultemail@somenet.foo"
73 assert u.save
73 assert u.save
74 u.reload
74 u.reload
75 assert u.email_address
75 assert u.email_address
76 assert_equal "defaultemail@somenet.foo", u.email_address.address
76 assert_equal "defaultemail@somenet.foo", u.email_address.address
77 assert_equal true, u.email_address.is_default
77 assert_equal true, u.email_address.is_default
78 assert_equal true, u.email_address.notify
78 assert_equal true, u.email_address.notify
79 end
79 end
80
80
81 def test_should_not_create_user_without_mail
81 def test_should_not_create_user_without_mail
82 set_language_if_valid 'en'
82 set_language_if_valid 'en'
83 u = User.new(:firstname => "new", :lastname => "user")
83 u = User.new(:firstname => "new", :lastname => "user")
84 u.login = "user_without_mail"
84 u.login = "user_without_mail"
85 assert !u.save
85 assert !u.save
86 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
86 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
87 end
87 end
88
88
89 def test_should_not_create_user_with_blank_mail
89 def test_should_not_create_user_with_blank_mail
90 set_language_if_valid 'en'
90 set_language_if_valid 'en'
91 u = User.new(:firstname => "new", :lastname => "user")
91 u = User.new(:firstname => "new", :lastname => "user")
92 u.login = "user_with_blank_mail"
92 u.login = "user_with_blank_mail"
93 u.mail = ''
93 u.mail = ''
94 assert !u.save
94 assert !u.save
95 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
95 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
96 end
96 end
97
97
98 def test_should_not_update_user_with_blank_mail
98 def test_should_not_update_user_with_blank_mail
99 set_language_if_valid 'en'
99 set_language_if_valid 'en'
100 u = User.find(2)
100 u = User.find(2)
101 u.mail = ''
101 u.mail = ''
102 assert !u.save
102 assert !u.save
103 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
103 assert_equal ["Email #{I18n.translate('activerecord.errors.messages.blank')}"], u.errors.full_messages
104 end
104 end
105
105
106 def test_login_length_validation
106 def test_login_length_validation
107 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
107 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
108 user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
108 user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
109 assert !user.valid?
109 assert !user.valid?
110
110
111 user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
111 user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
112 assert user.valid?
112 assert user.valid?
113 assert user.save
113 assert user.save
114 end
114 end
115
115
116 def test_generate_password_should_respect_minimum_password_length
116 def test_generate_password_should_respect_minimum_password_length
117 with_settings :password_min_length => 15 do
117 with_settings :password_min_length => 15 do
118 user = User.generate!(:generate_password => true)
118 user = User.generate!(:generate_password => true)
119 assert user.password.length >= 15
119 assert user.password.length >= 15
120 end
120 end
121 end
121 end
122
122
123 def test_generate_password_should_not_generate_password_with_less_than_10_characters
123 def test_generate_password_should_not_generate_password_with_less_than_10_characters
124 with_settings :password_min_length => 4 do
124 with_settings :password_min_length => 4 do
125 user = User.generate!(:generate_password => true)
125 user = User.generate!(:generate_password => true)
126 assert user.password.length >= 10
126 assert user.password.length >= 10
127 end
127 end
128 end
128 end
129
129
130 def test_generate_password_on_create_should_set_password
130 def test_generate_password_on_create_should_set_password
131 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
131 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
132 user.login = "newuser"
132 user.login = "newuser"
133 user.generate_password = true
133 user.generate_password = true
134 assert user.save
134 assert user.save
135
135
136 password = user.password
136 password = user.password
137 assert user.check_password?(password)
137 assert user.check_password?(password)
138 end
138 end
139
139
140 def test_generate_password_on_update_should_update_password
140 def test_generate_password_on_update_should_update_password
141 user = User.find(2)
141 user = User.find(2)
142 hash = user.hashed_password
142 hash = user.hashed_password
143 user.generate_password = true
143 user.generate_password = true
144 assert user.save
144 assert user.save
145
145
146 password = user.password
146 password = user.password
147 assert user.check_password?(password)
147 assert user.check_password?(password)
148 assert_not_equal hash, user.reload.hashed_password
148 assert_not_equal hash, user.reload.hashed_password
149 end
149 end
150
150
151 def test_create
151 def test_create
152 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
152 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
153
153
154 user.login = "jsmith"
154 user.login = "jsmith"
155 user.password, user.password_confirmation = "password", "password"
155 user.password, user.password_confirmation = "password", "password"
156 # login uniqueness
156 # login uniqueness
157 assert !user.save
157 assert !user.save
158 assert_equal 1, user.errors.count
158 assert_equal 1, user.errors.count
159
159
160 user.login = "newuser"
160 user.login = "newuser"
161 user.password, user.password_confirmation = "password", "pass"
161 user.password, user.password_confirmation = "password", "pass"
162 # password confirmation
162 # password confirmation
163 assert !user.save
163 assert !user.save
164 assert_equal 1, user.errors.count
164 assert_equal 1, user.errors.count
165
165
166 user.password, user.password_confirmation = "password", "password"
166 user.password, user.password_confirmation = "password", "password"
167 assert user.save
167 assert user.save
168 end
168 end
169
169
170 def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
170 def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
171 @user1 = User.generate!
171 @user1 = User.generate!
172 assert_equal 'only_my_events', @user1.mail_notification
172 assert_equal 'only_my_events', @user1.mail_notification
173 with_settings :default_notification_option => 'all' do
173 with_settings :default_notification_option => 'all' do
174 @user2 = User.generate!
174 @user2 = User.generate!
175 assert_equal 'all', @user2.mail_notification
175 assert_equal 'all', @user2.mail_notification
176 end
176 end
177 end
177 end
178
178
179 def test_user_login_should_be_case_insensitive
179 def test_user_login_should_be_case_insensitive
180 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
180 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
181 u.login = 'newuser'
181 u.login = 'newuser'
182 u.password, u.password_confirmation = "password", "password"
182 u.password, u.password_confirmation = "password", "password"
183 assert u.save
183 assert u.save
184 u = User.new(:firstname => "Similar", :lastname => "User",
184 u = User.new(:firstname => "Similar", :lastname => "User",
185 :mail => "similaruser@somenet.foo")
185 :mail => "similaruser@somenet.foo")
186 u.login = 'NewUser'
186 u.login = 'NewUser'
187 u.password, u.password_confirmation = "password", "password"
187 u.password, u.password_confirmation = "password", "password"
188 assert !u.save
188 assert !u.save
189 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
189 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
190 end
190 end
191
191
192 def test_mail_uniqueness_should_not_be_case_sensitive
192 def test_mail_uniqueness_should_not_be_case_sensitive
193 set_language_if_valid 'en'
193 set_language_if_valid 'en'
194 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
194 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
195 u.login = 'newuser1'
195 u.login = 'newuser1'
196 u.password, u.password_confirmation = "password", "password"
196 u.password, u.password_confirmation = "password", "password"
197 assert u.save
197 assert u.save
198
198
199 u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
199 u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
200 u.login = 'newuser2'
200 u.login = 'newuser2'
201 u.password, u.password_confirmation = "password", "password"
201 u.password, u.password_confirmation = "password", "password"
202 assert !u.save
202 assert !u.save
203 assert_include "Email #{I18n.translate('activerecord.errors.messages.taken')}", u.errors.full_messages
203 assert_include "Email #{I18n.translate('activerecord.errors.messages.taken')}", u.errors.full_messages
204 end
204 end
205
205
206 def test_update
206 def test_update
207 assert_equal "admin", @admin.login
207 assert_equal "admin", @admin.login
208 @admin.login = "john"
208 @admin.login = "john"
209 assert @admin.save, @admin.errors.full_messages.join("; ")
209 assert @admin.save, @admin.errors.full_messages.join("; ")
210 @admin.reload
210 @admin.reload
211 assert_equal "john", @admin.login
211 assert_equal "john", @admin.login
212 end
212 end
213
213
214 def test_update_should_not_fail_for_legacy_user_with_different_case_logins
214 def test_update_should_not_fail_for_legacy_user_with_different_case_logins
215 u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
215 u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
216 u1.login = 'newuser1'
216 u1.login = 'newuser1'
217 assert u1.save
217 assert u1.save
218
218
219 u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
219 u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
220 u2.login = 'newuser1'
220 u2.login = 'newuser1'
221 assert u2.save(:validate => false)
221 assert u2.save(:validate => false)
222
222
223 user = User.find(u2.id)
223 user = User.find(u2.id)
224 user.firstname = "firstname"
224 user.firstname = "firstname"
225 assert user.save, "Save failed"
225 assert user.save, "Save failed"
226 end
226 end
227
227
228 def test_destroy_should_delete_members_and_roles
228 def test_destroy_should_delete_members_and_roles
229 members = Member.where(:user_id => 2)
229 members = Member.where(:user_id => 2)
230 ms = members.count
230 ms = members.count
231 rs = members.collect(&:roles).flatten.size
231 rs = members.collect(&:roles).flatten.size
232 assert ms > 0
232 assert ms > 0
233 assert rs > 0
233 assert rs > 0
234 assert_difference 'Member.count', - ms do
234 assert_difference 'Member.count', - ms do
235 assert_difference 'MemberRole.count', - rs do
235 assert_difference 'MemberRole.count', - rs do
236 User.find(2).destroy
236 User.find(2).destroy
237 end
237 end
238 end
238 end
239 assert_nil User.find_by_id(2)
239 assert_nil User.find_by_id(2)
240 assert_equal 0, Member.where(:user_id => 2).count
240 assert_equal 0, Member.where(:user_id => 2).count
241 end
241 end
242
242
243 def test_destroy_should_update_attachments
243 def test_destroy_should_update_attachments
244 attachment = Attachment.create!(:container => Project.find(1),
244 attachment = Attachment.create!(:container => Project.find(1),
245 :file => uploaded_test_file("testfile.txt", "text/plain"),
245 :file => uploaded_test_file("testfile.txt", "text/plain"),
246 :author_id => 2)
246 :author_id => 2)
247
247
248 User.find(2).destroy
248 User.find(2).destroy
249 assert_nil User.find_by_id(2)
249 assert_nil User.find_by_id(2)
250 assert_equal User.anonymous, attachment.reload.author
250 assert_equal User.anonymous, attachment.reload.author
251 end
251 end
252
252
253 def test_destroy_should_update_comments
253 def test_destroy_should_update_comments
254 comment = Comment.create!(
254 comment = Comment.create!(
255 :commented => News.create!(:project_id => 1,
255 :commented => News.create!(:project_id => 1,
256 :author_id => 1, :title => 'foo', :description => 'foo'),
256 :author_id => 1, :title => 'foo', :description => 'foo'),
257 :author => User.find(2),
257 :author => User.find(2),
258 :comments => 'foo'
258 :comments => 'foo'
259 )
259 )
260
260
261 User.find(2).destroy
261 User.find(2).destroy
262 assert_nil User.find_by_id(2)
262 assert_nil User.find_by_id(2)
263 assert_equal User.anonymous, comment.reload.author
263 assert_equal User.anonymous, comment.reload.author
264 end
264 end
265
265
266 def test_destroy_should_update_issues
266 def test_destroy_should_update_issues
267 issue = Issue.create!(:project_id => 1, :author_id => 2,
267 issue = Issue.create!(:project_id => 1, :author_id => 2,
268 :tracker_id => 1, :subject => 'foo')
268 :tracker_id => 1, :subject => 'foo')
269
269
270 User.find(2).destroy
270 User.find(2).destroy
271 assert_nil User.find_by_id(2)
271 assert_nil User.find_by_id(2)
272 assert_equal User.anonymous, issue.reload.author
272 assert_equal User.anonymous, issue.reload.author
273 end
273 end
274
274
275 def test_destroy_should_unassign_issues
275 def test_destroy_should_unassign_issues
276 issue = Issue.create!(:project_id => 1, :author_id => 1,
276 issue = Issue.create!(:project_id => 1, :author_id => 1,
277 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
277 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
278
278
279 User.find(2).destroy
279 User.find(2).destroy
280 assert_nil User.find_by_id(2)
280 assert_nil User.find_by_id(2)
281 assert_nil issue.reload.assigned_to
281 assert_nil issue.reload.assigned_to
282 end
282 end
283
283
284 def test_destroy_should_update_journals
284 def test_destroy_should_update_journals
285 issue = Issue.create!(:project_id => 1, :author_id => 2,
285 issue = Issue.create!(:project_id => 1, :author_id => 2,
286 :tracker_id => 1, :subject => 'foo')
286 :tracker_id => 1, :subject => 'foo')
287 issue.init_journal(User.find(2), "update")
287 issue.init_journal(User.find(2), "update")
288 issue.save!
288 issue.save!
289
289
290 User.find(2).destroy
290 User.find(2).destroy
291 assert_nil User.find_by_id(2)
291 assert_nil User.find_by_id(2)
292 assert_equal User.anonymous, issue.journals.first.reload.user
292 assert_equal User.anonymous, issue.journals.first.reload.user
293 end
293 end
294
294
295 def test_destroy_should_update_journal_details_old_value
295 def test_destroy_should_update_journal_details_old_value
296 issue = Issue.create!(:project_id => 1, :author_id => 1,
296 issue = Issue.create!(:project_id => 1, :author_id => 1,
297 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
297 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
298 issue.init_journal(User.find(1), "update")
298 issue.init_journal(User.find(1), "update")
299 issue.assigned_to_id = nil
299 issue.assigned_to_id = nil
300 assert_difference 'JournalDetail.count' do
300 assert_difference 'JournalDetail.count' do
301 issue.save!
301 issue.save!
302 end
302 end
303 journal_detail = JournalDetail.order('id DESC').first
303 journal_detail = JournalDetail.order('id DESC').first
304 assert_equal '2', journal_detail.old_value
304 assert_equal '2', journal_detail.old_value
305
305
306 User.find(2).destroy
306 User.find(2).destroy
307 assert_nil User.find_by_id(2)
307 assert_nil User.find_by_id(2)
308 assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
308 assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
309 end
309 end
310
310
311 def test_destroy_should_update_journal_details_value
311 def test_destroy_should_update_journal_details_value
312 issue = Issue.create!(:project_id => 1, :author_id => 1,
312 issue = Issue.create!(:project_id => 1, :author_id => 1,
313 :tracker_id => 1, :subject => 'foo')
313 :tracker_id => 1, :subject => 'foo')
314 issue.init_journal(User.find(1), "update")
314 issue.init_journal(User.find(1), "update")
315 issue.assigned_to_id = 2
315 issue.assigned_to_id = 2
316 assert_difference 'JournalDetail.count' do
316 assert_difference 'JournalDetail.count' do
317 issue.save!
317 issue.save!
318 end
318 end
319 journal_detail = JournalDetail.order('id DESC').first
319 journal_detail = JournalDetail.order('id DESC').first
320 assert_equal '2', journal_detail.value
320 assert_equal '2', journal_detail.value
321
321
322 User.find(2).destroy
322 User.find(2).destroy
323 assert_nil User.find_by_id(2)
323 assert_nil User.find_by_id(2)
324 assert_equal User.anonymous.id.to_s, journal_detail.reload.value
324 assert_equal User.anonymous.id.to_s, journal_detail.reload.value
325 end
325 end
326
326
327 def test_destroy_should_update_messages
327 def test_destroy_should_update_messages
328 board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
328 board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
329 message = Message.create!(:board_id => board.id, :author_id => 2,
329 message = Message.create!(:board_id => board.id, :author_id => 2,
330 :subject => 'foo', :content => 'foo')
330 :subject => 'foo', :content => 'foo')
331 User.find(2).destroy
331 User.find(2).destroy
332 assert_nil User.find_by_id(2)
332 assert_nil User.find_by_id(2)
333 assert_equal User.anonymous, message.reload.author
333 assert_equal User.anonymous, message.reload.author
334 end
334 end
335
335
336 def test_destroy_should_update_news
336 def test_destroy_should_update_news
337 news = News.create!(:project_id => 1, :author_id => 2,
337 news = News.create!(:project_id => 1, :author_id => 2,
338 :title => 'foo', :description => 'foo')
338 :title => 'foo', :description => 'foo')
339 User.find(2).destroy
339 User.find(2).destroy
340 assert_nil User.find_by_id(2)
340 assert_nil User.find_by_id(2)
341 assert_equal User.anonymous, news.reload.author
341 assert_equal User.anonymous, news.reload.author
342 end
342 end
343
343
344 def test_destroy_should_delete_private_queries
344 def test_destroy_should_delete_private_queries
345 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
345 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
346 query.project_id = 1
346 query.project_id = 1
347 query.user_id = 2
347 query.user_id = 2
348 query.save!
348 query.save!
349
349
350 User.find(2).destroy
350 User.find(2).destroy
351 assert_nil User.find_by_id(2)
351 assert_nil User.find_by_id(2)
352 assert_nil Query.find_by_id(query.id)
352 assert_nil Query.find_by_id(query.id)
353 end
353 end
354
354
355 def test_destroy_should_update_public_queries
355 def test_destroy_should_update_public_queries
356 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
356 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
357 query.project_id = 1
357 query.project_id = 1
358 query.user_id = 2
358 query.user_id = 2
359 query.save!
359 query.save!
360
360
361 User.find(2).destroy
361 User.find(2).destroy
362 assert_nil User.find_by_id(2)
362 assert_nil User.find_by_id(2)
363 assert_equal User.anonymous, query.reload.user
363 assert_equal User.anonymous, query.reload.user
364 end
364 end
365
365
366 def test_destroy_should_update_time_entries
366 def test_destroy_should_update_time_entries
367 entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
367 entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
368 :activity => TimeEntryActivity.create!(:name => 'foo'))
368 :activity => TimeEntryActivity.create!(:name => 'foo'))
369 entry.project_id = 1
369 entry.project_id = 1
370 entry.user_id = 2
370 entry.user_id = 2
371 entry.save!
371 entry.save!
372
372
373 User.find(2).destroy
373 User.find(2).destroy
374 assert_nil User.find_by_id(2)
374 assert_nil User.find_by_id(2)
375 assert_equal User.anonymous, entry.reload.user
375 assert_equal User.anonymous, entry.reload.user
376 end
376 end
377
377
378 def test_destroy_should_delete_tokens
378 def test_destroy_should_delete_tokens
379 token = Token.create!(:user_id => 2, :value => 'foo')
379 token = Token.create!(:user_id => 2, :value => 'foo')
380
380
381 User.find(2).destroy
381 User.find(2).destroy
382 assert_nil User.find_by_id(2)
382 assert_nil User.find_by_id(2)
383 assert_nil Token.find_by_id(token.id)
383 assert_nil Token.find_by_id(token.id)
384 end
384 end
385
385
386 def test_destroy_should_delete_watchers
386 def test_destroy_should_delete_watchers
387 issue = Issue.create!(:project_id => 1, :author_id => 1,
387 issue = Issue.create!(:project_id => 1, :author_id => 1,
388 :tracker_id => 1, :subject => 'foo')
388 :tracker_id => 1, :subject => 'foo')
389 watcher = Watcher.create!(:user_id => 2, :watchable => issue)
389 watcher = Watcher.create!(:user_id => 2, :watchable => issue)
390
390
391 User.find(2).destroy
391 User.find(2).destroy
392 assert_nil User.find_by_id(2)
392 assert_nil User.find_by_id(2)
393 assert_nil Watcher.find_by_id(watcher.id)
393 assert_nil Watcher.find_by_id(watcher.id)
394 end
394 end
395
395
396 def test_destroy_should_update_wiki_contents
396 def test_destroy_should_update_wiki_contents
397 wiki_content = WikiContent.create!(
397 wiki_content = WikiContent.create!(
398 :text => 'foo',
398 :text => 'foo',
399 :author_id => 2,
399 :author_id => 2,
400 :page => WikiPage.create!(:title => 'Foo',
400 :page => WikiPage.create!(:title => 'Foo',
401 :wiki => Wiki.create!(:project_id => 3,
401 :wiki => Wiki.create!(:project_id => 3,
402 :start_page => 'Start'))
402 :start_page => 'Start'))
403 )
403 )
404 wiki_content.text = 'bar'
404 wiki_content.text = 'bar'
405 assert_difference 'WikiContent::Version.count' do
405 assert_difference 'WikiContent::Version.count' do
406 wiki_content.save!
406 wiki_content.save!
407 end
407 end
408
408
409 User.find(2).destroy
409 User.find(2).destroy
410 assert_nil User.find_by_id(2)
410 assert_nil User.find_by_id(2)
411 assert_equal User.anonymous, wiki_content.reload.author
411 assert_equal User.anonymous, wiki_content.reload.author
412 wiki_content.versions.each do |version|
412 wiki_content.versions.each do |version|
413 assert_equal User.anonymous, version.reload.author
413 assert_equal User.anonymous, version.reload.author
414 end
414 end
415 end
415 end
416
416
417 def test_destroy_should_nullify_issue_categories
417 def test_destroy_should_nullify_issue_categories
418 category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
418 category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
419
419
420 User.find(2).destroy
420 User.find(2).destroy
421 assert_nil User.find_by_id(2)
421 assert_nil User.find_by_id(2)
422 assert_nil category.reload.assigned_to_id
422 assert_nil category.reload.assigned_to_id
423 end
423 end
424
424
425 def test_destroy_should_nullify_changesets
425 def test_destroy_should_nullify_changesets
426 changeset = Changeset.create!(
426 changeset = Changeset.create!(
427 :repository => Repository::Subversion.create!(
427 :repository => Repository::Subversion.create!(
428 :project_id => 1,
428 :project_id => 1,
429 :url => 'file:///tmp',
429 :url => 'file:///tmp',
430 :identifier => 'tmp'
430 :identifier => 'tmp'
431 ),
431 ),
432 :revision => '12',
432 :revision => '12',
433 :committed_on => Time.now,
433 :committed_on => Time.now,
434 :committer => 'jsmith'
434 :committer => 'jsmith'
435 )
435 )
436 assert_equal 2, changeset.user_id
436 assert_equal 2, changeset.user_id
437
437
438 User.find(2).destroy
438 User.find(2).destroy
439 assert_nil User.find_by_id(2)
439 assert_nil User.find_by_id(2)
440 assert_nil changeset.reload.user_id
440 assert_nil changeset.reload.user_id
441 end
441 end
442
442
443 def test_anonymous_user_should_not_be_destroyable
443 def test_anonymous_user_should_not_be_destroyable
444 assert_no_difference 'User.count' do
444 assert_no_difference 'User.count' do
445 assert_equal false, User.anonymous.destroy
445 assert_equal false, User.anonymous.destroy
446 end
446 end
447 end
447 end
448
448
449 def test_password_change_should_destroy_tokens
449 def test_password_change_should_destroy_tokens
450 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
450 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
451 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
451 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
452
452
453 user = User.find(2)
453 user = User.find(2)
454 user.password, user.password_confirmation = "a new password", "a new password"
454 user.password, user.password_confirmation = "a new password", "a new password"
455 assert user.save
455 assert user.save
456
456
457 assert_nil Token.find_by_id(recovery_token.id)
457 assert_nil Token.find_by_id(recovery_token.id)
458 assert_nil Token.find_by_id(autologin_token.id)
458 assert_nil Token.find_by_id(autologin_token.id)
459 end
459 end
460
460
461 def test_mail_change_should_destroy_tokens
461 def test_mail_change_should_destroy_tokens
462 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
462 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
463 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
463 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
464
464
465 user = User.find(2)
465 user = User.find(2)
466 user.mail = "user@somwehere.com"
466 user.mail = "user@somwehere.com"
467 assert user.save
467 assert user.save
468
468
469 assert_nil Token.find_by_id(recovery_token.id)
469 assert_nil Token.find_by_id(recovery_token.id)
470 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
470 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
471 end
471 end
472
472
473 def test_change_on_other_fields_should_not_destroy_tokens
473 def test_change_on_other_fields_should_not_destroy_tokens
474 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
474 recovery_token = Token.create!(:user_id => 2, :action => 'recovery')
475 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
475 autologin_token = Token.create!(:user_id => 2, :action => 'autologin')
476
476
477 user = User.find(2)
477 user = User.find(2)
478 user.firstname = "Bobby"
478 user.firstname = "Bobby"
479 assert user.save
479 assert user.save
480
480
481 assert_equal recovery_token, Token.find_by_id(recovery_token.id)
481 assert_equal recovery_token, Token.find_by_id(recovery_token.id)
482 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
482 assert_equal autologin_token, Token.find_by_id(autologin_token.id)
483 end
483 end
484
484
485 def test_validate_login_presence
485 def test_validate_login_presence
486 @admin.login = ""
486 @admin.login = ""
487 assert !@admin.save
487 assert !@admin.save
488 assert_equal 1, @admin.errors.count
488 assert_equal 1, @admin.errors.count
489 end
489 end
490
490
491 def test_validate_mail_notification_inclusion
491 def test_validate_mail_notification_inclusion
492 u = User.new
492 u = User.new
493 u.mail_notification = 'foo'
493 u.mail_notification = 'foo'
494 u.save
494 u.save
495 assert_not_equal [], u.errors[:mail_notification]
495 assert_not_equal [], u.errors[:mail_notification]
496 end
496 end
497
497
498 def test_password
498 def test_password
499 user = User.try_to_login("admin", "admin")
499 user = User.try_to_login("admin", "admin")
500 assert_kind_of User, user
500 assert_kind_of User, user
501 assert_equal "admin", user.login
501 assert_equal "admin", user.login
502 user.password = "hello123"
502 user.password = "hello123"
503 assert user.save
503 assert user.save
504
504
505 user = User.try_to_login("admin", "hello123")
505 user = User.try_to_login("admin", "hello123")
506 assert_kind_of User, user
506 assert_kind_of User, user
507 assert_equal "admin", user.login
507 assert_equal "admin", user.login
508 end
508 end
509
509
510 def test_validate_password_length
510 def test_validate_password_length
511 with_settings :password_min_length => '100' do
511 with_settings :password_min_length => '100' do
512 user = User.new(:firstname => "new100",
512 user = User.new(:firstname => "new100",
513 :lastname => "user100", :mail => "newuser100@somenet.foo")
513 :lastname => "user100", :mail => "newuser100@somenet.foo")
514 user.login = "newuser100"
514 user.login = "newuser100"
515 user.password, user.password_confirmation = "password100", "password100"
515 user.password, user.password_confirmation = "password100", "password100"
516 assert !user.save
516 assert !user.save
517 assert_equal 1, user.errors.count
517 assert_equal 1, user.errors.count
518 end
518 end
519 end
519 end
520
520
521 def test_name_format
521 def test_name_format
522 assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
522 assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
523 assert_equal 'Smith, John', @jsmith.name(:lastname_comma_firstname)
523 assert_equal 'Smith, John', @jsmith.name(:lastname_comma_firstname)
524 assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
524 assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
525 assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
525 assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
526 end
526 end
527
527
528 def test_name_should_use_setting_as_default_format
528 def test_name_should_use_setting_as_default_format
529 with_settings :user_format => :firstname_lastname do
529 with_settings :user_format => :firstname_lastname do
530 assert_equal 'John Smith', @jsmith.reload.name
530 assert_equal 'John Smith', @jsmith.reload.name
531 end
531 end
532 with_settings :user_format => :username do
532 with_settings :user_format => :username do
533 assert_equal 'jsmith', @jsmith.reload.name
533 assert_equal 'jsmith', @jsmith.reload.name
534 end
534 end
535 with_settings :user_format => :lastname do
535 with_settings :user_format => :lastname do
536 assert_equal 'Smith', @jsmith.reload.name
536 assert_equal 'Smith', @jsmith.reload.name
537 end
537 end
538 end
538 end
539
539
540 def test_today_should_return_the_day_according_to_user_time_zone
540 def test_today_should_return_the_day_according_to_user_time_zone
541 preference = User.find(1).pref
541 preference = User.find(1).pref
542 date = Date.new(2012, 05, 15)
542 date = Date.new(2012, 05, 15)
543 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
543 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
544 Date.stubs(:today).returns(date)
544 Date.stubs(:today).returns(date)
545 Time.stubs(:now).returns(time)
545 Time.stubs(:now).returns(time)
546
546
547 preference.update_attribute :time_zone, 'Baku' # UTC+4
547 preference.update_attribute :time_zone, 'Baku' # UTC+4
548 assert_equal '2012-05-16', User.find(1).today.to_s
548 assert_equal '2012-05-16', User.find(1).today.to_s
549
549
550 preference.update_attribute :time_zone, 'La Paz' # UTC-4
550 preference.update_attribute :time_zone, 'La Paz' # UTC-4
551 assert_equal '2012-05-15', User.find(1).today.to_s
551 assert_equal '2012-05-15', User.find(1).today.to_s
552
552
553 preference.update_attribute :time_zone, ''
553 preference.update_attribute :time_zone, ''
554 assert_equal '2012-05-15', User.find(1).today.to_s
554 assert_equal '2012-05-15', User.find(1).today.to_s
555 end
555 end
556
556
557 def test_time_to_date_should_return_the_date_according_to_user_time_zone
557 def test_time_to_date_should_return_the_date_according_to_user_time_zone
558 preference = User.find(1).pref
558 preference = User.find(1).pref
559 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
559 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
560
560
561 preference.update_attribute :time_zone, 'Baku' # UTC+4
561 preference.update_attribute :time_zone, 'Baku' # UTC+4
562 assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
562 assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
563
563
564 preference.update_attribute :time_zone, 'La Paz' # UTC-4
564 preference.update_attribute :time_zone, 'La Paz' # UTC-4
565 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
565 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
566
566
567 preference.update_attribute :time_zone, ''
567 preference.update_attribute :time_zone, ''
568 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
568 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
569 end
569 end
570
570
571 def test_fields_for_order_statement_should_return_fields_according_user_format_setting
571 def test_fields_for_order_statement_should_return_fields_according_user_format_setting
572 with_settings :user_format => 'lastname_comma_firstname' do
572 with_settings :user_format => 'lastname_comma_firstname' do
573 assert_equal ['users.lastname', 'users.firstname', 'users.id'],
573 assert_equal ['users.lastname', 'users.firstname', 'users.id'],
574 User.fields_for_order_statement
574 User.fields_for_order_statement
575 end
575 end
576 end
576 end
577
577
578 def test_fields_for_order_statement_width_table_name_should_prepend_table_name
578 def test_fields_for_order_statement_width_table_name_should_prepend_table_name
579 with_settings :user_format => 'lastname_firstname' do
579 with_settings :user_format => 'lastname_firstname' do
580 assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
580 assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
581 User.fields_for_order_statement('authors')
581 User.fields_for_order_statement('authors')
582 end
582 end
583 end
583 end
584
584
585 def test_fields_for_order_statement_with_blank_format_should_return_default
585 def test_fields_for_order_statement_with_blank_format_should_return_default
586 with_settings :user_format => '' do
586 with_settings :user_format => '' do
587 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
587 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
588 User.fields_for_order_statement
588 User.fields_for_order_statement
589 end
589 end
590 end
590 end
591
591
592 def test_fields_for_order_statement_with_invalid_format_should_return_default
592 def test_fields_for_order_statement_with_invalid_format_should_return_default
593 with_settings :user_format => 'foo' do
593 with_settings :user_format => 'foo' do
594 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
594 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
595 User.fields_for_order_statement
595 User.fields_for_order_statement
596 end
596 end
597 end
597 end
598
598
599 test ".try_to_login with good credentials should return the user" do
599 test ".try_to_login with good credentials should return the user" do
600 user = User.try_to_login("admin", "admin")
600 user = User.try_to_login("admin", "admin")
601 assert_kind_of User, user
601 assert_kind_of User, user
602 assert_equal "admin", user.login
602 assert_equal "admin", user.login
603 end
603 end
604
604
605 test ".try_to_login with wrong credentials should return nil" do
605 test ".try_to_login with wrong credentials should return nil" do
606 assert_nil User.try_to_login("admin", "foo")
606 assert_nil User.try_to_login("admin", "foo")
607 end
607 end
608
608
609 def test_try_to_login_with_locked_user_should_return_nil
609 def test_try_to_login_with_locked_user_should_return_nil
610 @jsmith.status = User::STATUS_LOCKED
610 @jsmith.status = User::STATUS_LOCKED
611 @jsmith.save!
611 @jsmith.save!
612
612
613 user = User.try_to_login("jsmith", "jsmith")
613 user = User.try_to_login("jsmith", "jsmith")
614 assert_nil user
614 assert_nil user
615 end
615 end
616
616
617 def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
617 def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
618 @jsmith.status = User::STATUS_LOCKED
618 @jsmith.status = User::STATUS_LOCKED
619 @jsmith.save!
619 @jsmith.save!
620
620
621 user = User.try_to_login("jsmith", "jsmith", false)
621 user = User.try_to_login("jsmith", "jsmith", false)
622 assert_equal @jsmith, user
622 assert_equal @jsmith, user
623 end
623 end
624
624
625 test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
625 test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
626 user = User.try_to_login("AdMin", "admin")
626 user = User.try_to_login("AdMin", "admin")
627 assert_kind_of User, user
627 assert_kind_of User, user
628 assert_equal "admin", user.login
628 assert_equal "admin", user.login
629 end
629 end
630
630
631 test ".try_to_login should select the exact matching user first" do
631 test ".try_to_login should select the exact matching user first" do
632 case_sensitive_user = User.generate! do |user|
632 case_sensitive_user = User.generate! do |user|
633 user.password = "admin123"
633 user.password = "admin123"
634 end
634 end
635 # bypass validations to make it appear like existing data
635 # bypass validations to make it appear like existing data
636 case_sensitive_user.update_attribute(:login, 'ADMIN')
636 case_sensitive_user.update_attribute(:login, 'ADMIN')
637
637
638 user = User.try_to_login("ADMIN", "admin123")
638 user = User.try_to_login("ADMIN", "admin123")
639 assert_kind_of User, user
639 assert_kind_of User, user
640 assert_equal "ADMIN", user.login
640 assert_equal "ADMIN", user.login
641 end
641 end
642
642
643 if ldap_configured?
643 if ldap_configured?
644 test "#try_to_login using LDAP with failed connection to the LDAP server" do
644 test "#try_to_login using LDAP with failed connection to the LDAP server" do
645 auth_source = AuthSourceLdap.find(1)
645 auth_source = AuthSourceLdap.find(1)
646 AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
646 AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
647
647
648 assert_nil User.try_to_login('edavis', 'wrong')
648 assert_nil User.try_to_login('edavis', 'wrong')
649 end
649 end
650
650
651 test "#try_to_login using LDAP" do
651 test "#try_to_login using LDAP" do
652 assert_nil User.try_to_login('edavis', 'wrong')
652 assert_nil User.try_to_login('edavis', 'wrong')
653 end
653 end
654
654
655 test "#try_to_login using LDAP binding with user's account" do
655 test "#try_to_login using LDAP binding with user's account" do
656 auth_source = AuthSourceLdap.find(1)
656 auth_source = AuthSourceLdap.find(1)
657 auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
657 auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
658 auth_source.account_password = ''
658 auth_source.account_password = ''
659 auth_source.save!
659 auth_source.save!
660
660
661 ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
661 ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
662 ldap_user.login = 'example1'
662 ldap_user.login = 'example1'
663 ldap_user.save!
663 ldap_user.save!
664
664
665 assert_equal ldap_user, User.try_to_login('example1', '123456')
665 assert_equal ldap_user, User.try_to_login('example1', '123456')
666 assert_nil User.try_to_login('example1', '11111')
666 assert_nil User.try_to_login('example1', '11111')
667 end
667 end
668
668
669 test "#try_to_login using LDAP on the fly registration" do
669 test "#try_to_login using LDAP on the fly registration" do
670 AuthSourceLdap.find(1).update_attribute :onthefly_register, true
670 AuthSourceLdap.find(1).update_attribute :onthefly_register, true
671
671
672 assert_difference('User.count') do
672 assert_difference('User.count') do
673 assert User.try_to_login('edavis', '123456')
673 assert User.try_to_login('edavis', '123456')
674 end
674 end
675
675
676 assert_no_difference('User.count') do
676 assert_no_difference('User.count') do
677 assert User.try_to_login('edavis', '123456')
677 assert User.try_to_login('edavis', '123456')
678 end
678 end
679
679
680 assert_nil User.try_to_login('example1', '11111')
680 assert_nil User.try_to_login('example1', '11111')
681 end
681 end
682
682
683 test "#try_to_login using LDAP on the fly registration and binding with user's account" do
683 test "#try_to_login using LDAP on the fly registration and binding with user's account" do
684 auth_source = AuthSourceLdap.find(1)
684 auth_source = AuthSourceLdap.find(1)
685 auth_source.update_attribute :onthefly_register, true
685 auth_source.update_attribute :onthefly_register, true
686 auth_source = AuthSourceLdap.find(1)
686 auth_source = AuthSourceLdap.find(1)
687 auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
687 auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
688 auth_source.account_password = ''
688 auth_source.account_password = ''
689 auth_source.save!
689 auth_source.save!
690
690
691 assert_difference('User.count') do
691 assert_difference('User.count') do
692 assert User.try_to_login('example1', '123456')
692 assert User.try_to_login('example1', '123456')
693 end
693 end
694
694
695 assert_no_difference('User.count') do
695 assert_no_difference('User.count') do
696 assert User.try_to_login('example1', '123456')
696 assert User.try_to_login('example1', '123456')
697 end
697 end
698
698
699 assert_nil User.try_to_login('example1', '11111')
699 assert_nil User.try_to_login('example1', '11111')
700 end
700 end
701
701
702 else
702 else
703 puts "Skipping LDAP tests."
703 puts "Skipping LDAP tests."
704 end
704 end
705
705
706 def test_create_anonymous
706 def test_create_anonymous
707 AnonymousUser.delete_all
707 AnonymousUser.delete_all
708 anon = User.anonymous
708 anon = User.anonymous
709 assert !anon.new_record?
709 assert !anon.new_record?
710 assert_kind_of AnonymousUser, anon
710 assert_kind_of AnonymousUser, anon
711 end
711 end
712
712
713 def test_ensure_single_anonymous_user
713 def test_ensure_single_anonymous_user
714 AnonymousUser.delete_all
714 AnonymousUser.delete_all
715 anon1 = User.anonymous
715 anon1 = User.anonymous
716 assert !anon1.new_record?
716 assert !anon1.new_record?
717 assert_kind_of AnonymousUser, anon1
717 assert_kind_of AnonymousUser, anon1
718 anon2 = AnonymousUser.create(
718 anon2 = AnonymousUser.create(
719 :lastname => 'Anonymous', :firstname => '',
719 :lastname => 'Anonymous', :firstname => '',
720 :login => '', :status => 0)
720 :login => '', :status => 0)
721 assert_equal 1, anon2.errors.count
721 assert_equal 1, anon2.errors.count
722 end
722 end
723
723
724 def test_rss_key
724 def test_rss_key
725 assert_nil @jsmith.rss_token
725 assert_nil @jsmith.rss_token
726 key = @jsmith.rss_key
726 key = @jsmith.rss_key
727 assert_equal 40, key.length
727 assert_equal 40, key.length
728
728
729 @jsmith.reload
729 @jsmith.reload
730 assert_equal key, @jsmith.rss_key
730 assert_equal key, @jsmith.rss_key
731 end
731 end
732
732
733 def test_rss_key_should_not_be_generated_twice
733 def test_rss_key_should_not_be_generated_twice
734 assert_difference 'Token.count', 1 do
734 assert_difference 'Token.count', 1 do
735 key1 = @jsmith.rss_key
735 key1 = @jsmith.rss_key
736 key2 = @jsmith.rss_key
736 key2 = @jsmith.rss_key
737 assert_equal key1, key2
737 assert_equal key1, key2
738 end
738 end
739 end
739 end
740
740
741 def test_api_key_should_not_be_generated_twice
741 def test_api_key_should_not_be_generated_twice
742 assert_difference 'Token.count', 1 do
742 assert_difference 'Token.count', 1 do
743 key1 = @jsmith.api_key
743 key1 = @jsmith.api_key
744 key2 = @jsmith.api_key
744 key2 = @jsmith.api_key
745 assert_equal key1, key2
745 assert_equal key1, key2
746 end
746 end
747 end
747 end
748
748
749 test "#api_key should generate a new one if the user doesn't have one" do
749 test "#api_key should generate a new one if the user doesn't have one" do
750 user = User.generate!(:api_token => nil)
750 user = User.generate!(:api_token => nil)
751 assert_nil user.api_token
751 assert_nil user.api_token
752
752
753 key = user.api_key
753 key = user.api_key
754 assert_equal 40, key.length
754 assert_equal 40, key.length
755 user.reload
755 user.reload
756 assert_equal key, user.api_key
756 assert_equal key, user.api_key
757 end
757 end
758
758
759 test "#api_key should return the existing api token value" do
759 test "#api_key should return the existing api token value" do
760 user = User.generate!
760 user = User.generate!
761 token = Token.create!(:action => 'api')
761 token = Token.create!(:action => 'api')
762 user.api_token = token
762 user.api_token = token
763 assert user.save
763 assert user.save
764
764
765 assert_equal token.value, user.api_key
765 assert_equal token.value, user.api_key
766 end
766 end
767
767
768 test "#find_by_api_key should return nil if no matching key is found" do
768 test "#find_by_api_key should return nil if no matching key is found" do
769 assert_nil User.find_by_api_key('zzzzzzzzz')
769 assert_nil User.find_by_api_key('zzzzzzzzz')
770 end
770 end
771
771
772 test "#find_by_api_key should return nil if the key is found for an inactive user" do
772 test "#find_by_api_key should return nil if the key is found for an inactive user" do
773 user = User.generate!
773 user = User.generate!
774 user.status = User::STATUS_LOCKED
774 user.status = User::STATUS_LOCKED
775 token = Token.create!(:action => 'api')
775 token = Token.create!(:action => 'api')
776 user.api_token = token
776 user.api_token = token
777 user.save
777 user.save
778
778
779 assert_nil User.find_by_api_key(token.value)
779 assert_nil User.find_by_api_key(token.value)
780 end
780 end
781
781
782 test "#find_by_api_key should return the user if the key is found for an active user" do
782 test "#find_by_api_key should return the user if the key is found for an active user" do
783 user = User.generate!
783 user = User.generate!
784 token = Token.create!(:action => 'api')
784 token = Token.create!(:action => 'api')
785 user.api_token = token
785 user.api_token = token
786 user.save
786 user.save
787
787
788 assert_equal user, User.find_by_api_key(token.value)
788 assert_equal user, User.find_by_api_key(token.value)
789 end
789 end
790
790
791 def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
791 def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
792 user = User.find_by_login("admin")
792 user = User.find_by_login("admin")
793 user.password = "admin"
793 user.password = "admin"
794 assert user.save(:validate => false)
794 assert user.save(:validate => false)
795
795
796 assert_equal false, User.default_admin_account_changed?
796 assert_equal false, User.default_admin_account_changed?
797 end
797 end
798
798
799 def test_default_admin_account_changed_should_return_true_if_password_was_changed
799 def test_default_admin_account_changed_should_return_true_if_password_was_changed
800 user = User.find_by_login("admin")
800 user = User.find_by_login("admin")
801 user.password = "newpassword"
801 user.password = "newpassword"
802 user.save!
802 user.save!
803
803
804 assert_equal true, User.default_admin_account_changed?
804 assert_equal true, User.default_admin_account_changed?
805 end
805 end
806
806
807 def test_default_admin_account_changed_should_return_true_if_account_is_disabled
807 def test_default_admin_account_changed_should_return_true_if_account_is_disabled
808 user = User.find_by_login("admin")
808 user = User.find_by_login("admin")
809 user.password = "admin"
809 user.password = "admin"
810 user.status = User::STATUS_LOCKED
810 user.status = User::STATUS_LOCKED
811 assert user.save(:validate => false)
811 assert user.save(:validate => false)
812
812
813 assert_equal true, User.default_admin_account_changed?
813 assert_equal true, User.default_admin_account_changed?
814 end
814 end
815
815
816 def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
816 def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
817 user = User.find_by_login("admin")
817 user = User.find_by_login("admin")
818 user.destroy
818 user.destroy
819
819
820 assert_equal true, User.default_admin_account_changed?
820 assert_equal true, User.default_admin_account_changed?
821 end
821 end
822
822
823 def test_membership_with_project_should_return_membership
823 def test_membership_with_project_should_return_membership
824 project = Project.find(1)
824 project = Project.find(1)
825
825
826 membership = @jsmith.membership(project)
826 membership = @jsmith.membership(project)
827 assert_kind_of Member, membership
827 assert_kind_of Member, membership
828 assert_equal @jsmith, membership.user
828 assert_equal @jsmith, membership.user
829 assert_equal project, membership.project
829 assert_equal project, membership.project
830 end
830 end
831
831
832 def test_membership_with_project_id_should_return_membership
832 def test_membership_with_project_id_should_return_membership
833 project = Project.find(1)
833 project = Project.find(1)
834
834
835 membership = @jsmith.membership(1)
835 membership = @jsmith.membership(1)
836 assert_kind_of Member, membership
836 assert_kind_of Member, membership
837 assert_equal @jsmith, membership.user
837 assert_equal @jsmith, membership.user
838 assert_equal project, membership.project
838 assert_equal project, membership.project
839 end
839 end
840
840
841 def test_membership_for_non_member_should_return_nil
841 def test_membership_for_non_member_should_return_nil
842 project = Project.find(1)
842 project = Project.find(1)
843
843
844 user = User.generate!
844 user = User.generate!
845 membership = user.membership(1)
845 membership = user.membership(1)
846 assert_nil membership
846 assert_nil membership
847 end
847 end
848
848
849 def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
849 def test_roles_for_project_with_member_on_public_project_should_return_roles_and_non_member
850 roles = @jsmith.roles_for_project(Project.find(1))
850 roles = @jsmith.roles_for_project(Project.find(1))
851 assert_kind_of Role, roles.first
851 assert_kind_of Role, roles.first
852 assert_equal ["Manager"], roles.map(&:name)
852 assert_equal ["Manager"], roles.map(&:name)
853 end
853 end
854
854
855 def test_roles_for_project_with_member_on_private_project_should_return_roles
855 def test_roles_for_project_with_member_on_private_project_should_return_roles
856 Project.find(1).update_attribute :is_public, false
856 Project.find(1).update_attribute :is_public, false
857
857
858 roles = @jsmith.roles_for_project(Project.find(1))
858 roles = @jsmith.roles_for_project(Project.find(1))
859 assert_kind_of Role, roles.first
859 assert_kind_of Role, roles.first
860 assert_equal ["Manager"], roles.map(&:name)
860 assert_equal ["Manager"], roles.map(&:name)
861 end
861 end
862
862
863 def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
863 def test_roles_for_project_with_non_member_with_public_project_should_return_non_member
864 set_language_if_valid 'en'
864 set_language_if_valid 'en'
865 roles = User.find(8).roles_for_project(Project.find(1))
865 roles = User.find(8).roles_for_project(Project.find(1))
866 assert_equal ["Non member"], roles.map(&:name)
866 assert_equal ["Non member"], roles.map(&:name)
867 end
867 end
868
868
869 def test_roles_for_project_with_non_member_with_public_project_and_override_should_return_override_roles
869 def test_roles_for_project_with_non_member_with_public_project_and_override_should_return_override_roles
870 project = Project.find(1)
870 project = Project.find(1)
871 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
871 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
872 roles = User.find(8).roles_for_project(project)
872 roles = User.find(8).roles_for_project(project)
873 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
873 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
874 end
874 end
875
875
876 def test_roles_for_project_with_non_member_with_private_project_should_return_no_roles
876 def test_roles_for_project_with_non_member_with_private_project_should_return_no_roles
877 Project.find(1).update_attribute :is_public, false
877 Project.find(1).update_attribute :is_public, false
878
879 roles = User.find(8).roles_for_project(Project.find(1))
878 roles = User.find(8).roles_for_project(Project.find(1))
880 assert_equal [], roles.map(&:name)
879 assert_equal [], roles.map(&:name)
881 end
880 end
882
881
883 def test_roles_for_project_with_non_member_with_private_project_and_override_should_return_no_roles
882 def test_roles_for_project_with_non_member_with_private_project_and_override_should_return_no_roles
884 project = Project.find(1)
883 project = Project.find(1)
885 project.update_attribute :is_public, false
884 project.update_attribute :is_public, false
886 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
885 Member.create!(:project => project, :principal => Group.non_member, :role_ids => [1, 2])
887 roles = User.find(8).roles_for_project(project)
886 roles = User.find(8).roles_for_project(project)
888 assert_equal [], roles.map(&:name).sort
887 assert_equal [], roles.map(&:name).sort
889 end
888 end
890
889
891 def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
890 def test_roles_for_project_with_anonymous_with_public_project_should_return_anonymous
892 set_language_if_valid 'en'
891 set_language_if_valid 'en'
893 roles = User.anonymous.roles_for_project(Project.find(1))
892 roles = User.anonymous.roles_for_project(Project.find(1))
894 assert_equal ["Anonymous"], roles.map(&:name)
893 assert_equal ["Anonymous"], roles.map(&:name)
895 end
894 end
896
895
897 def test_roles_for_project_with_anonymous_with_public_project_and_override_should_return_override_roles
896 def test_roles_for_project_with_anonymous_with_public_project_and_override_should_return_override_roles
898 project = Project.find(1)
897 project = Project.find(1)
899 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
898 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
900 roles = User.anonymous.roles_for_project(project)
899 roles = User.anonymous.roles_for_project(project)
901 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
900 assert_equal ["Developer", "Manager"], roles.map(&:name).sort
902 end
901 end
903
902
904 def test_roles_for_project_with_anonymous_with_private_project_should_return_no_roles
903 def test_roles_for_project_with_anonymous_with_private_project_should_return_no_roles
905 Project.find(1).update_attribute :is_public, false
904 Project.find(1).update_attribute :is_public, false
906
907 roles = User.anonymous.roles_for_project(Project.find(1))
905 roles = User.anonymous.roles_for_project(Project.find(1))
908 assert_equal [], roles.map(&:name)
906 assert_equal [], roles.map(&:name)
909 end
907 end
910
908
911 def test_roles_for_project_with_anonymous_with_private_project_and_override_should_return_no_roles
909 def test_roles_for_project_with_anonymous_with_private_project_and_override_should_return_no_roles
912 project = Project.find(1)
910 project = Project.find(1)
913 project.update_attribute :is_public, false
911 project.update_attribute :is_public, false
914 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
912 Member.create!(:project => project, :principal => Group.anonymous, :role_ids => [1, 2])
915 roles = User.anonymous.roles_for_project(project)
913 roles = User.anonymous.roles_for_project(project)
916 assert_equal [], roles.map(&:name).sort
914 assert_equal [], roles.map(&:name).sort
917 end
915 end
918
916
919 def test_roles_for_project_should_be_unique
917 def test_roles_for_project_should_be_unique
920 m = Member.new(:user_id => 1, :project_id => 1)
918 m = Member.new(:user_id => 1, :project_id => 1)
921 m.member_roles.build(:role_id => 1)
919 m.member_roles.build(:role_id => 1)
922 m.member_roles.build(:role_id => 1)
920 m.member_roles.build(:role_id => 1)
923 m.save!
921 m.save!
924
922
925 user = User.find(1)
923 user = User.find(1)
926 project = Project.find(1)
924 project = Project.find(1)
927 assert_equal 1, user.roles_for_project(project).size
925 assert_equal 1, user.roles_for_project(project).size
928 assert_equal [1], user.roles_for_project(project).map(&:id)
926 assert_equal [1], user.roles_for_project(project).map(&:id)
929 end
927 end
930
928
931 def test_projects_by_role_for_user_with_role
929 def test_projects_by_role_for_user_with_role
932 user = User.find(2)
930 user = User.find(2)
933 assert_kind_of Hash, user.projects_by_role
931 assert_kind_of Hash, user.projects_by_role
934 assert_equal 2, user.projects_by_role.size
932 assert_equal 2, user.projects_by_role.size
935 assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
933 assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
936 assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
934 assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
937 end
935 end
938
936
939 def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
937 def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
940 user = User.find(2)
938 user = User.find(2)
941 assert_equal [], user.projects_by_role[Role.find(3)]
939 assert_equal [], user.projects_by_role[Role.find(3)]
942 # should not update the hash
940 # should not update the hash
943 assert_nil user.projects_by_role.values.detect(&:blank?)
941 assert_nil user.projects_by_role.values.detect(&:blank?)
944 end
942 end
945
943
946 def test_projects_by_role_for_user_with_no_role
944 def test_projects_by_role_for_user_with_no_role
947 user = User.generate!
945 user = User.generate!
948 assert_equal({}, user.projects_by_role)
946 assert_equal({}, user.projects_by_role)
949 end
947 end
950
948
951 def test_projects_by_role_for_anonymous
949 def test_projects_by_role_for_anonymous
952 assert_equal({}, User.anonymous.projects_by_role)
950 assert_equal({}, User.anonymous.projects_by_role)
953 end
951 end
954
952
955 def test_valid_notification_options
953 def test_valid_notification_options
956 # without memberships
954 # without memberships
957 assert_equal 5, User.find(7).valid_notification_options.size
955 assert_equal 5, User.find(7).valid_notification_options.size
958 # with memberships
956 # with memberships
959 assert_equal 6, User.find(2).valid_notification_options.size
957 assert_equal 6, User.find(2).valid_notification_options.size
960 end
958 end
961
959
962 def test_valid_notification_options_class_method
960 def test_valid_notification_options_class_method
963 assert_equal 5, User.valid_notification_options.size
961 assert_equal 5, User.valid_notification_options.size
964 assert_equal 5, User.valid_notification_options(User.find(7)).size
962 assert_equal 5, User.valid_notification_options(User.find(7)).size
965 assert_equal 6, User.valid_notification_options(User.find(2)).size
963 assert_equal 6, User.valid_notification_options(User.find(2)).size
966 end
964 end
967
965
968 def test_notified_project_ids_setter_should_coerce_to_unique_integer_array
966 def test_notified_project_ids_setter_should_coerce_to_unique_integer_array
969 @jsmith.notified_project_ids = ["1", "123", "2u", "wrong", "12", 6, 12, -35, ""]
967 @jsmith.notified_project_ids = ["1", "123", "2u", "wrong", "12", 6, 12, -35, ""]
970 assert_equal [1, 123, 2, 12, 6], @jsmith.notified_projects_ids
968 assert_equal [1, 123, 2, 12, 6], @jsmith.notified_projects_ids
971 end
969 end
972
970
973 def test_mail_notification_all
971 def test_mail_notification_all
974 @jsmith.mail_notification = 'all'
972 @jsmith.mail_notification = 'all'
975 @jsmith.notified_project_ids = []
973 @jsmith.notified_project_ids = []
976 @jsmith.save
974 @jsmith.save
977 @jsmith.reload
975 @jsmith.reload
978 assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
976 assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
979 end
977 end
980
978
981 def test_mail_notification_selected
979 def test_mail_notification_selected
982 @jsmith.mail_notification = 'selected'
980 @jsmith.mail_notification = 'selected'
983 @jsmith.notified_project_ids = [1]
981 @jsmith.notified_project_ids = [1]
984 @jsmith.save
982 @jsmith.save
985 @jsmith.reload
983 @jsmith.reload
986 assert Project.find(1).recipients.include?(@jsmith.mail)
984 assert Project.find(1).recipients.include?(@jsmith.mail)
987 end
985 end
988
986
989 def test_mail_notification_only_my_events
987 def test_mail_notification_only_my_events
990 @jsmith.mail_notification = 'only_my_events'
988 @jsmith.mail_notification = 'only_my_events'
991 @jsmith.notified_project_ids = []
989 @jsmith.notified_project_ids = []
992 @jsmith.save
990 @jsmith.save
993 @jsmith.reload
991 @jsmith.reload
994 assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
992 assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
995 end
993 end
996
994
997 def test_comments_sorting_preference
995 def test_comments_sorting_preference
998 assert !@jsmith.wants_comments_in_reverse_order?
996 assert !@jsmith.wants_comments_in_reverse_order?
999 @jsmith.pref.comments_sorting = 'asc'
997 @jsmith.pref.comments_sorting = 'asc'
1000 assert !@jsmith.wants_comments_in_reverse_order?
998 assert !@jsmith.wants_comments_in_reverse_order?
1001 @jsmith.pref.comments_sorting = 'desc'
999 @jsmith.pref.comments_sorting = 'desc'
1002 assert @jsmith.wants_comments_in_reverse_order?
1000 assert @jsmith.wants_comments_in_reverse_order?
1003 end
1001 end
1004
1002
1005 def test_find_by_mail_should_be_case_insensitive
1003 def test_find_by_mail_should_be_case_insensitive
1006 u = User.find_by_mail('JSmith@somenet.foo')
1004 u = User.find_by_mail('JSmith@somenet.foo')
1007 assert_not_nil u
1005 assert_not_nil u
1008 assert_equal 'jsmith@somenet.foo', u.mail
1006 assert_equal 'jsmith@somenet.foo', u.mail
1009 end
1007 end
1010
1008
1011 def test_random_password
1009 def test_random_password
1012 u = User.new
1010 u = User.new
1013 u.random_password
1011 u.random_password
1014 assert !u.password.blank?
1012 assert !u.password.blank?
1015 assert !u.password_confirmation.blank?
1013 assert !u.password_confirmation.blank?
1016 end
1014 end
1017
1015
1018 test "#change_password_allowed? should be allowed if no auth source is set" do
1016 test "#change_password_allowed? should be allowed if no auth source is set" do
1019 user = User.generate!
1017 user = User.generate!
1020 assert user.change_password_allowed?
1018 assert user.change_password_allowed?
1021 end
1019 end
1022
1020
1023 test "#change_password_allowed? should delegate to the auth source" do
1021 test "#change_password_allowed? should delegate to the auth source" do
1024 user = User.generate!
1022 user = User.generate!
1025
1023
1026 allowed_auth_source = AuthSource.generate!
1024 allowed_auth_source = AuthSource.generate!
1027 def allowed_auth_source.allow_password_changes?; true; end
1025 def allowed_auth_source.allow_password_changes?; true; end
1028
1026
1029 denied_auth_source = AuthSource.generate!
1027 denied_auth_source = AuthSource.generate!
1030 def denied_auth_source.allow_password_changes?; false; end
1028 def denied_auth_source.allow_password_changes?; false; end
1031
1029
1032 assert user.change_password_allowed?
1030 assert user.change_password_allowed?
1033
1031
1034 user.auth_source = allowed_auth_source
1032 user.auth_source = allowed_auth_source
1035 assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
1033 assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
1036
1034
1037 user.auth_source = denied_auth_source
1035 user.auth_source = denied_auth_source
1038 assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
1036 assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
1039 end
1037 end
1040
1038
1041 def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
1039 def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
1042 with_settings :unsubscribe => '1' do
1040 with_settings :unsubscribe => '1' do
1043 assert_equal true, User.find(2).own_account_deletable?
1041 assert_equal true, User.find(2).own_account_deletable?
1044 end
1042 end
1045 end
1043 end
1046
1044
1047 def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
1045 def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
1048 with_settings :unsubscribe => '0' do
1046 with_settings :unsubscribe => '0' do
1049 assert_equal false, User.find(2).own_account_deletable?
1047 assert_equal false, User.find(2).own_account_deletable?
1050 end
1048 end
1051 end
1049 end
1052
1050
1053 def test_own_account_deletable_should_be_false_for_a_single_admin
1051 def test_own_account_deletable_should_be_false_for_a_single_admin
1054 User.where(["admin = ? AND id <> ?", true, 1]).delete_all
1052 User.where(["admin = ? AND id <> ?", true, 1]).delete_all
1055
1053
1056 with_settings :unsubscribe => '1' do
1054 with_settings :unsubscribe => '1' do
1057 assert_equal false, User.find(1).own_account_deletable?
1055 assert_equal false, User.find(1).own_account_deletable?
1058 end
1056 end
1059 end
1057 end
1060
1058
1061 def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
1059 def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
1062 User.generate! do |user|
1060 User.generate! do |user|
1063 user.admin = true
1061 user.admin = true
1064 end
1062 end
1065
1063
1066 with_settings :unsubscribe => '1' do
1064 with_settings :unsubscribe => '1' do
1067 assert_equal true, User.find(1).own_account_deletable?
1065 assert_equal true, User.find(1).own_account_deletable?
1068 end
1066 end
1069 end
1067 end
1070
1068
1071 test "#allowed_to? for archived project should return false" do
1069 test "#allowed_to? for archived project should return false" do
1072 project = Project.find(1)
1070 project = Project.find(1)
1073 project.archive
1071 project.archive
1074 project.reload
1072 project.reload
1075 assert_equal false, @admin.allowed_to?(:view_issues, project)
1073 assert_equal false, @admin.allowed_to?(:view_issues, project)
1076 end
1074 end
1077
1075
1078 test "#allowed_to? for closed project should return true for read actions" do
1076 test "#allowed_to? for closed project should return true for read actions" do
1079 project = Project.find(1)
1077 project = Project.find(1)
1080 project.close
1078 project.close
1081 project.reload
1079 project.reload
1082 assert_equal false, @admin.allowed_to?(:edit_project, project)
1080 assert_equal false, @admin.allowed_to?(:edit_project, project)
1083 assert_equal true, @admin.allowed_to?(:view_project, project)
1081 assert_equal true, @admin.allowed_to?(:view_project, project)
1084 end
1082 end
1085
1083
1086 test "#allowed_to? for project with module disabled should return false" do
1084 test "#allowed_to? for project with module disabled should return false" do
1087 project = Project.find(1)
1085 project = Project.find(1)
1088 project.enabled_module_names = ["issue_tracking"]
1086 project.enabled_module_names = ["issue_tracking"]
1089 assert_equal true, @admin.allowed_to?(:add_issues, project)
1087 assert_equal true, @admin.allowed_to?(:add_issues, project)
1090 assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
1088 assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
1091 end
1089 end
1092
1090
1093 test "#allowed_to? for admin users should return true" do
1091 test "#allowed_to? for admin users should return true" do
1094 project = Project.find(1)
1092 project = Project.find(1)
1095 assert ! @admin.member_of?(project)
1093 assert ! @admin.member_of?(project)
1096 %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
1094 %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
1097 assert_equal true, @admin.allowed_to?(p.to_sym, project)
1095 assert_equal true, @admin.allowed_to?(p.to_sym, project)
1098 end
1096 end
1099 end
1097 end
1100
1098
1101 test "#allowed_to? for normal users" do
1099 test "#allowed_to? for normal users" do
1102 project = Project.find(1)
1100 project = Project.find(1)
1103 assert_equal true, @jsmith.allowed_to?(:delete_messages, project) #Manager
1101 assert_equal true, @jsmith.allowed_to?(:delete_messages, project) #Manager
1104 assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
1102 assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
1105 end
1103 end
1106
1104
1107 test "#allowed_to? with empty array should return false" do
1105 test "#allowed_to? with empty array should return false" do
1108 assert_equal false, @admin.allowed_to?(:view_project, [])
1106 assert_equal false, @admin.allowed_to?(:view_project, [])
1109 end
1107 end
1110
1108
1111 test "#allowed_to? with multiple projects" do
1109 test "#allowed_to? with multiple projects" do
1112 assert_equal true, @admin.allowed_to?(:view_project, Project.all.to_a)
1110 assert_equal true, @admin.allowed_to?(:view_project, Project.all.to_a)
1113 assert_equal false, @dlopper.allowed_to?(:view_project, Project.all.to_a) #cannot see Project(2)
1111 assert_equal false, @dlopper.allowed_to?(:view_project, Project.all.to_a) #cannot see Project(2)
1114 assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects.to_a) #Manager or Developer everywhere
1112 assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects.to_a) #Manager or Developer everywhere
1115 assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects.to_a) #Dev cannot delete_issue_watchers
1113 assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects.to_a) #Dev cannot delete_issue_watchers
1116 end
1114 end
1117
1115
1118 test "#allowed_to? with with options[:global] should return true if user has one role with the permission" do
1116 test "#allowed_to? with with options[:global] should return true if user has one role with the permission" do
1119 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
1117 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
1120 @anonymous = User.find(6)
1118 @anonymous = User.find(6)
1121 assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
1119 assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
1122 assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
1120 assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
1123 assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
1121 assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
1124 assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
1122 assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
1125 assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
1123 assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
1126 end
1124 end
1127
1125
1128 # this is just a proxy method, the test only calls it to ensure it doesn't break trivially
1126 # this is just a proxy method, the test only calls it to ensure it doesn't break trivially
1129 test "#allowed_to_globally?" do
1127 test "#allowed_to_globally?" do
1130 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
1128 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
1131 @anonymous = User.find(6)
1129 @anonymous = User.find(6)
1132 assert_equal true, @jsmith.allowed_to_globally?(:delete_issue_watchers)
1130 assert_equal true, @jsmith.allowed_to_globally?(:delete_issue_watchers)
1133 assert_equal false, @dlopper2.allowed_to_globally?(:delete_issue_watchers)
1131 assert_equal false, @dlopper2.allowed_to_globally?(:delete_issue_watchers)
1134 assert_equal true, @dlopper2.allowed_to_globally?(:add_issues)
1132 assert_equal true, @dlopper2.allowed_to_globally?(:add_issues)
1135 assert_equal false, @anonymous.allowed_to_globally?(:add_issues)
1133 assert_equal false, @anonymous.allowed_to_globally?(:add_issues)
1136 assert_equal true, @anonymous.allowed_to_globally?(:view_issues)
1134 assert_equal true, @anonymous.allowed_to_globally?(:view_issues)
1137 end
1135 end
1138
1136
1139 def test_notify_about_issue
1137 def test_notify_about_issue
1140 project = Project.find(1)
1138 project = Project.find(1)
1141 author = User.generate!
1139 author = User.generate!
1142 assignee = User.generate!
1140 assignee = User.generate!
1143 Member.create!(:user => assignee, :project => project, :role_ids => [1])
1141 Member.create!(:user => assignee, :project => project, :role_ids => [1])
1144 member = User.generate!
1142 member = User.generate!
1145 Member.create!(:user => member, :project => project, :role_ids => [1])
1143 Member.create!(:user => member, :project => project, :role_ids => [1])
1146 issue = Issue.generate!(:project => project, :assigned_to => assignee, :author => author)
1144 issue = Issue.generate!(:project => project, :assigned_to => assignee, :author => author)
1147
1145
1148 tests = {
1146 tests = {
1149 author => %w(all only_my_events only_owner selected),
1147 author => %w(all only_my_events only_owner selected),
1150 assignee => %w(all only_my_events only_assigned selected),
1148 assignee => %w(all only_my_events only_assigned selected),
1151 member => %w(all)
1149 member => %w(all)
1152 }
1150 }
1153
1151
1154 tests.each do |user, expected|
1152 tests.each do |user, expected|
1155 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
1153 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
1156 user.mail_notification = option
1154 user.mail_notification = option
1157 assert_equal expected.include?(option), user.notify_about?(issue)
1155 assert_equal expected.include?(option), user.notify_about?(issue)
1158 end
1156 end
1159 end
1157 end
1160 end
1158 end
1161
1159
1162 def test_notify_about_issue_for_previous_assignee
1160 def test_notify_about_issue_for_previous_assignee
1163 assignee = User.generate!(:mail_notification => 'only_assigned')
1161 assignee = User.generate!(:mail_notification => 'only_assigned')
1164 Member.create!(:user => assignee, :project_id => 1, :role_ids => [1])
1162 Member.create!(:user => assignee, :project_id => 1, :role_ids => [1])
1165 new_assignee = User.generate!(:mail_notification => 'only_assigned')
1163 new_assignee = User.generate!(:mail_notification => 'only_assigned')
1166 Member.create!(:user => new_assignee, :project_id => 1, :role_ids => [1])
1164 Member.create!(:user => new_assignee, :project_id => 1, :role_ids => [1])
1167 issue = Issue.generate!(:assigned_to => assignee)
1165 issue = Issue.generate!(:assigned_to => assignee)
1168
1166
1169 assert assignee.notify_about?(issue)
1167 assert assignee.notify_about?(issue)
1170 assert !new_assignee.notify_about?(issue)
1168 assert !new_assignee.notify_about?(issue)
1171
1169
1172 issue.assigned_to = new_assignee
1170 issue.assigned_to = new_assignee
1173 assert assignee.notify_about?(issue)
1171 assert assignee.notify_about?(issue)
1174 assert new_assignee.notify_about?(issue)
1172 assert new_assignee.notify_about?(issue)
1175
1173
1176 issue.save!
1174 issue.save!
1177 assert !assignee.notify_about?(issue)
1175 assert !assignee.notify_about?(issue)
1178 assert new_assignee.notify_about?(issue)
1176 assert new_assignee.notify_about?(issue)
1179 end
1177 end
1180
1178
1181 def test_notify_about_news
1179 def test_notify_about_news
1182 user = User.generate!
1180 user = User.generate!
1183 news = News.new
1181 news = News.new
1184
1182
1185 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
1183 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
1186 user.mail_notification = option
1184 user.mail_notification = option
1187 assert_equal (option != 'none'), user.notify_about?(news)
1185 assert_equal (option != 'none'), user.notify_about?(news)
1188 end
1186 end
1189 end
1187 end
1190
1188
1191 def test_salt_unsalted_passwords
1189 def test_salt_unsalted_passwords
1192 # Restore a user with an unsalted password
1190 # Restore a user with an unsalted password
1193 user = User.find(1)
1191 user = User.find(1)
1194 user.salt = nil
1192 user.salt = nil
1195 user.hashed_password = User.hash_password("unsalted")
1193 user.hashed_password = User.hash_password("unsalted")
1196 user.save!
1194 user.save!
1197
1195
1198 User.salt_unsalted_passwords!
1196 User.salt_unsalted_passwords!
1199
1197
1200 user.reload
1198 user.reload
1201 # Salt added
1199 # Salt added
1202 assert !user.salt.blank?
1200 assert !user.salt.blank?
1203 # Password still valid
1201 # Password still valid
1204 assert user.check_password?("unsalted")
1202 assert user.check_password?("unsalted")
1205 assert_equal user, User.try_to_login(user.login, "unsalted")
1203 assert_equal user, User.try_to_login(user.login, "unsalted")
1206 end
1204 end
1207
1205
1208 if Object.const_defined?(:OpenID)
1206 if Object.const_defined?(:OpenID)
1209 def test_setting_identity_url
1207 def test_setting_identity_url
1210 normalized_open_id_url = 'http://example.com/'
1208 normalized_open_id_url = 'http://example.com/'
1211 u = User.new( :identity_url => 'http://example.com/' )
1209 u = User.new( :identity_url => 'http://example.com/' )
1212 assert_equal normalized_open_id_url, u.identity_url
1210 assert_equal normalized_open_id_url, u.identity_url
1213 end
1211 end
1214
1212
1215 def test_setting_identity_url_without_trailing_slash
1213 def test_setting_identity_url_without_trailing_slash
1216 normalized_open_id_url = 'http://example.com/'
1214 normalized_open_id_url = 'http://example.com/'
1217 u = User.new( :identity_url => 'http://example.com' )
1215 u = User.new( :identity_url => 'http://example.com' )
1218 assert_equal normalized_open_id_url, u.identity_url
1216 assert_equal normalized_open_id_url, u.identity_url
1219 end
1217 end
1220
1218
1221 def test_setting_identity_url_without_protocol
1219 def test_setting_identity_url_without_protocol
1222 normalized_open_id_url = 'http://example.com/'
1220 normalized_open_id_url = 'http://example.com/'
1223 u = User.new( :identity_url => 'example.com' )
1221 u = User.new( :identity_url => 'example.com' )
1224 assert_equal normalized_open_id_url, u.identity_url
1222 assert_equal normalized_open_id_url, u.identity_url
1225 end
1223 end
1226
1224
1227 def test_setting_blank_identity_url
1225 def test_setting_blank_identity_url
1228 u = User.new( :identity_url => 'example.com' )
1226 u = User.new( :identity_url => 'example.com' )
1229 u.identity_url = ''
1227 u.identity_url = ''
1230 assert u.identity_url.blank?
1228 assert u.identity_url.blank?
1231 end
1229 end
1232
1230
1233 def test_setting_invalid_identity_url
1231 def test_setting_invalid_identity_url
1234 u = User.new( :identity_url => 'this is not an openid url' )
1232 u = User.new( :identity_url => 'this is not an openid url' )
1235 assert u.identity_url.blank?
1233 assert u.identity_url.blank?
1236 end
1234 end
1237 else
1235 else
1238 puts "Skipping openid tests."
1236 puts "Skipping openid tests."
1239 end
1237 end
1240 end
1238 end
General Comments 0
You need to be logged in to leave comments. Login now