]> git.openstreetmap.org Git - rails.git/blob - test/controllers/users_controller_test.rb
6e156375b289fea99221627758aaf72e028eb0c7
[rails.git] / test / controllers / users_controller_test.rb
1 require "test_helper"
2
3 class UsersControllerTest < ActionDispatch::IntegrationTest
4   ##
5   # test all routes which lead to this controller
6   def test_routes
7     assert_routing(
8       { :path => "/user/new", :method => :get },
9       { :controller => "users", :action => "new" }
10     )
11
12     assert_routing(
13       { :path => "/user/new", :method => :post },
14       { :controller => "users", :action => "create" }
15     )
16
17     assert_routing(
18       { :path => "/user/terms", :method => :get },
19       { :controller => "users", :action => "terms" }
20     )
21
22     assert_routing(
23       { :path => "/user/save", :method => :post },
24       { :controller => "users", :action => "save" }
25     )
26
27     assert_routing(
28       { :path => "/user/go_public", :method => :post },
29       { :controller => "users", :action => "go_public" }
30     )
31
32     assert_routing(
33       { :path => "/user/suspended", :method => :get },
34       { :controller => "users", :action => "suspended" }
35     )
36
37     assert_routing(
38       { :path => "/user/username", :method => :get },
39       { :controller => "users", :action => "show", :display_name => "username" }
40     )
41
42     assert_routing(
43       { :path => "/user/username/account", :method => :get },
44       { :controller => "users", :action => "account", :display_name => "username" }
45     )
46     assert_routing(
47       { :path => "/user/username/account", :method => :post },
48       { :controller => "users", :action => "account", :display_name => "username" }
49     )
50
51     assert_routing(
52       { :path => "/user/username/set_status", :method => :post },
53       { :controller => "users", :action => "set_status", :display_name => "username" }
54     )
55     assert_routing(
56       { :path => "/user/username", :method => :delete },
57       { :controller => "users", :action => "destroy", :display_name => "username" }
58     )
59
60     assert_routing(
61       { :path => "/users", :method => :get },
62       { :controller => "users", :action => "index" }
63     )
64     assert_routing(
65       { :path => "/users", :method => :post },
66       { :controller => "users", :action => "index" }
67     )
68     assert_routing(
69       { :path => "/users/status", :method => :get },
70       { :controller => "users", :action => "index", :status => "status" }
71     )
72     assert_routing(
73       { :path => "/users/status", :method => :post },
74       { :controller => "users", :action => "index", :status => "status" }
75     )
76   end
77
78   # The user creation page loads
79   def test_new_view
80     get user_new_path
81     assert_response :redirect
82     assert_redirected_to user_new_path(:cookie_test => "true")
83
84     get user_new_path, :params => { :cookie_test => "true" }
85     assert_response :success
86
87     assert_select "html", :count => 1 do
88       assert_select "head", :count => 1 do
89         assert_select "title", :text => /Sign Up/, :count => 1
90       end
91       assert_select "body", :count => 1 do
92         assert_select "div#content", :count => 1 do
93           assert_select "form[action='/user/new'][method='post']", :count => 1 do
94             assert_select "input[id='user_email']", :count => 1
95             assert_select "input[id='user_email_confirmation']", :count => 1
96             assert_select "input[id='user_display_name']", :count => 1
97             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
98             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
99             assert_select "input[type='submit'][value='Sign Up']", :count => 1
100           end
101         end
102       end
103     end
104   end
105
106   def test_new_view_logged_in
107     session_for(create(:user))
108
109     get user_new_path
110     assert_response :redirect
111     assert_redirected_to root_path
112
113     get user_new_path, :params => { :referer => "/test" }
114     assert_response :redirect
115     assert_redirected_to "/test"
116   end
117
118   def test_new_success
119     user = build(:user, :pending)
120
121     assert_no_difference "User.count" do
122       assert_no_difference "ActionMailer::Base.deliveries.size" do
123         perform_enqueued_jobs do
124           post user_new_path, :params => { :user => user.attributes }
125         end
126       end
127     end
128
129     assert_difference "User.count", 1 do
130       assert_difference "ActionMailer::Base.deliveries.size", 1 do
131         perform_enqueued_jobs do
132           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
133         end
134       end
135     end
136
137     # Check the e-mail
138     register_email = ActionMailer::Base.deliveries.first
139
140     assert_equal register_email.to[0], user.email
141     assert_match(/#{@url}/, register_email.body.to_s)
142
143     # Check the page
144     assert_redirected_to :controller => :confirmations, :action => :confirm, :display_name => user.display_name
145
146     ActionMailer::Base.deliveries.clear
147   end
148
149   def test_new_duplicate_email
150     user = build(:user, :pending)
151     create(:user, :email => user.email)
152
153     assert_no_difference "User.count" do
154       assert_no_difference "ActionMailer::Base.deliveries.size" do
155         perform_enqueued_jobs do
156           post user_new_path, :params => { :user => user.attributes }
157         end
158       end
159     end
160
161     assert_response :success
162     assert_template "new"
163     assert_select "form > div.form-group > input.is-invalid#user_email"
164   end
165
166   def test_save_duplicate_email
167     user = build(:user, :pending)
168
169     # Set up our user as being half-way through registration
170     assert_no_difference "User.count" do
171       assert_no_difference "ActionMailer::Base.deliveries.size" do
172         perform_enqueued_jobs do
173           post user_new_path, :params => { :user => user.attributes }
174         end
175       end
176     end
177
178     # Now create another user with that email
179     create(:user, :email => user.email)
180
181     # Check that the second half of registration fails
182     assert_no_difference "User.count" do
183       assert_no_difference "ActionMailer::Base.deliveries.size" do
184         perform_enqueued_jobs do
185           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
186         end
187       end
188     end
189
190     assert_response :success
191     assert_template "new"
192     assert_select "form > div.form-group > input.is-invalid#user_email"
193   end
194
195   def test_save_duplicate_email_uppercase
196     user = build(:user, :pending)
197
198     # Set up our user as being half-way through registration
199     assert_no_difference "User.count" do
200       assert_no_difference "ActionMailer::Base.deliveries.size" do
201         perform_enqueued_jobs do
202           post user_new_path, :params => { :user => user.attributes }
203         end
204       end
205     end
206
207     # Now create another user with that email, but uppercased
208     create(:user, :email => user.email.upcase)
209
210     # Check that the second half of registration fails
211     assert_no_difference "User.count" do
212       assert_no_difference "ActionMailer::Base.deliveries.size" do
213         perform_enqueued_jobs do
214           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
215         end
216       end
217     end
218
219     assert_response :success
220     assert_template "new"
221     assert_select "form > div.form-group > input.is-invalid#user_email"
222   end
223
224   def test_save_duplicate_name
225     user = build(:user, :pending)
226
227     # Set up our user as being half-way through registration
228     assert_no_difference "User.count" do
229       assert_no_difference "ActionMailer::Base.deliveries.size" do
230         perform_enqueued_jobs do
231           post user_new_path, :params => { :user => user.attributes }
232         end
233       end
234     end
235
236     # Now create another user with that display name
237     create(:user, :display_name => user.display_name)
238
239     # Check that the second half of registration fails
240     assert_no_difference "User.count" do
241       assert_no_difference "ActionMailer::Base.deliveries.size" do
242         perform_enqueued_jobs do
243           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
244         end
245       end
246     end
247
248     assert_response :success
249     assert_template "new"
250     assert_select "form > div.form-group > input.is-invalid#user_display_name"
251   end
252
253   def test_save_duplicate_name_uppercase
254     user = build(:user, :pending)
255
256     # Set up our user as being half-way through registration
257     assert_no_difference "User.count" do
258       assert_no_difference "ActionMailer::Base.deliveries.size" do
259         perform_enqueued_jobs do
260           post user_new_path, :params => { :user => user.attributes }
261         end
262       end
263     end
264
265     # Now create another user with that display_name, but uppercased
266     create(:user, :display_name => user.display_name.upcase)
267
268     # Check that the second half of registration fails
269     assert_no_difference "User.count" do
270       assert_no_difference "ActionMailer::Base.deliveries.size" do
271         perform_enqueued_jobs do
272           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
273         end
274       end
275     end
276
277     assert_response :success
278     assert_template "new"
279     assert_select "form > div.form-group > input.is-invalid#user_display_name"
280   end
281
282   def test_save_blocked_domain
283     user = build(:user, :pending, :email => "user@example.net")
284
285     # Set up our user as being half-way through registration
286     assert_no_difference "User.count" do
287       assert_no_difference "ActionMailer::Base.deliveries.size" do
288         perform_enqueued_jobs do
289           post user_new_path, :params => { :user => user.attributes }
290         end
291       end
292     end
293
294     # Now block that domain
295     create(:acl, :domain => "example.net", :k => "no_account_creation")
296
297     # Check that the second half of registration fails
298     assert_no_difference "User.count" do
299       assert_no_difference "ActionMailer::Base.deliveries.size" do
300         perform_enqueued_jobs do
301           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
302         end
303       end
304     end
305
306     assert_response :success
307     assert_template "blocked"
308   end
309
310   def test_save_referer_params
311     user = build(:user, :pending)
312
313     # Set up our user as being half-way through registration
314     assert_no_difference "User.count" do
315       assert_no_difference "ActionMailer::Base.deliveries.size" do
316         perform_enqueued_jobs do
317           post user_new_path, :params => { :user => user.attributes, :referer => "/edit?editor=id#map=1/2/3" }
318         end
319       end
320     end
321
322     assert_difference "User.count", 1 do
323       assert_difference "ActionMailer::Base.deliveries.size", 1 do
324         perform_enqueued_jobs do
325           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
326         end
327       end
328     end
329
330     assert_equal welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3),
331                  User.find_by(:email => user.email).tokens.order("id DESC").first.referer
332
333     ActionMailer::Base.deliveries.clear
334   end
335
336   def test_terms_new_user
337     user = build(:user, :pending)
338
339     # Set up our user as being half-way through registration
340     assert_no_difference "User.count" do
341       assert_no_difference "ActionMailer::Base.deliveries.size" do
342         perform_enqueued_jobs do
343           post user_new_path, :params => { :user => user.attributes }
344         end
345       end
346     end
347
348     get user_terms_path
349
350     assert_response :success
351     assert_template :terms
352   end
353
354   def test_terms_agreed
355     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
356
357     session_for(user)
358
359     get user_terms_path
360     assert_response :redirect
361     assert_redirected_to :action => :account, :display_name => user.display_name
362   end
363
364   def test_terms_not_seen_without_referer
365     user = create(:user, :terms_seen => false, :terms_agreed => nil)
366
367     session_for(user)
368
369     get user_terms_path
370     assert_response :success
371     assert_template :terms
372
373     post user_save_path, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
374     assert_response :redirect
375     assert_redirected_to :action => :account, :display_name => user.display_name
376     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
377
378     user.reload
379
380     assert user.consider_pd
381     assert_not_nil user.terms_agreed
382     assert user.terms_seen
383   end
384
385   def test_terms_not_seen_with_referer
386     user = create(:user, :terms_seen => false, :terms_agreed => nil)
387
388     session_for(user)
389
390     get user_terms_path, :params => { :referer => "/test" }
391     assert_response :success
392     assert_template :terms
393
394     post user_save_path, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
395     assert_response :redirect
396     assert_redirected_to "/test"
397     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
398
399     user.reload
400
401     assert user.consider_pd
402     assert_not_nil user.terms_agreed
403     assert user.terms_seen
404   end
405
406   # Check that if you haven't seen the terms, and make a request that requires authentication,
407   # that your request is redirected to view the terms
408   def test_terms_not_seen_redirection
409     user = create(:user, :terms_seen => false, :terms_agreed => nil)
410     session_for(user)
411
412     get user_account_path(user)
413     assert_response :redirect
414     assert_redirected_to :action => :terms, :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
415   end
416
417   def test_terms_not_logged_in
418     get user_terms_path
419
420     assert_redirected_to login_path(:referer => "/user/terms")
421   end
422
423   def test_go_public
424     user = create(:user, :data_public => false)
425     session_for(user)
426
427     post user_go_public_path
428
429     assert_response :redirect
430     assert_redirected_to :action => :account, :display_name => user.display_name
431     assert User.find(user.id).data_public
432   end
433
434   def test_account
435     # Get a user to work with - note that this user deliberately
436     # conflicts with uppercase_user in the email and display name
437     # fields to test that we can change other fields without any
438     # validation errors being reported
439     user = create(:user, :languages => [])
440     _uppercase_user = build(:user, :email => user.email.upcase, :display_name => user.display_name.upcase).tap { |u| u.save(:validate => false) }
441
442     # Make sure that you are redirected to the login page when
443     # you are not logged in
444     get user_account_path(user)
445     assert_response :redirect
446     assert_redirected_to login_path(:referer => "/user/#{ERB::Util.u(user.display_name)}/account")
447
448     # Make sure that you are blocked when not logged in as the right user
449     session_for(create(:user))
450     get user_account_path(user)
451     assert_response :forbidden
452
453     # Make sure we get the page when we are logged in as the right user
454     session_for(user)
455     get user_account_path(user)
456     assert_response :success
457     assert_template :account
458     assert_select "form#accountForm" do |form|
459       assert_equal "post", form.attr("method").to_s
460       assert_select "input[name='_method']", false
461       assert_equal "/user/#{ERB::Util.u(user.display_name)}/account", form.attr("action").to_s
462     end
463
464     # Updating the description using GET should fail
465     user.description = "new description"
466     user.preferred_editor = "default"
467     get user_account_path(user), :params => { :user => user.attributes }
468     assert_response :success
469     assert_template :account
470     assert_not_equal user.description, User.find(user.id).description
471
472     # Adding external authentication should redirect to the auth provider
473     post user_account_path(user), :params => { :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }
474     assert_response :redirect
475     assert_redirected_to auth_path(:provider => "openid", :openid_url => "https://www.google.com/accounts/o8/id", :origin => "/user/#{ERB::Util.u(user.display_name)}/account")
476
477     # Changing name to one that exists should fail
478     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name)
479     post user_account_path(user), :params => { :user => new_attributes }
480     assert_response :success
481     assert_template :account
482     assert_select ".notice", false
483     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
484
485     # Changing name to one that exists should fail, regardless of case
486     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name.upcase)
487     post user_account_path(user), :params => { :user => new_attributes }
488     assert_response :success
489     assert_template :account
490     assert_select ".notice", false
491     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
492
493     # Changing name to one that doesn't exist should work
494     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
495     post user_account_path(user), :params => { :user => new_attributes }
496     assert_response :redirect
497     assert_redirected_to user_account_url(:display_name => "new tester")
498     get user_account_path(:display_name => "new tester")
499     assert_response :success
500     assert_template :account
501     assert_select ".notice", /^User information updated successfully/
502     assert_select "form#accountForm > div.form-group > input#user_display_name[value=?]", "new tester"
503
504     # Record the change of name
505     user.display_name = "new tester"
506
507     # Changing email to one that exists should fail
508     user.new_email = create(:user).email
509     assert_no_difference "ActionMailer::Base.deliveries.size" do
510       perform_enqueued_jobs do
511         post user_account_path(user), :params => { :user => user.attributes }
512       end
513     end
514     assert_response :success
515     assert_template :account
516     assert_select ".notice", false
517     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
518
519     # Changing email to one that exists should fail, regardless of case
520     user.new_email = create(:user).email.upcase
521     assert_no_difference "ActionMailer::Base.deliveries.size" do
522       perform_enqueued_jobs do
523         post user_account_path(user), :params => { :user => user.attributes }
524       end
525     end
526     assert_response :success
527     assert_template :account
528     assert_select ".notice", false
529     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
530
531     # Changing email to one that doesn't exist should work
532     user.new_email = "new_tester@example.com"
533     assert_difference "ActionMailer::Base.deliveries.size", 1 do
534       perform_enqueued_jobs do
535         post user_account_path(user), :params => { :user => user.attributes }
536       end
537     end
538     assert_response :redirect
539     assert_redirected_to user_account_url(user)
540     get user_account_path(user)
541     assert_response :success
542     assert_template :account
543     assert_select ".notice", /^User information updated successfully/
544     assert_select "form#accountForm > div.form-group > input#user_new_email[value=?]", user.new_email
545     email = ActionMailer::Base.deliveries.first
546     assert_equal 1, email.to.count
547     assert_equal user.new_email, email.to.first
548     ActionMailer::Base.deliveries.clear
549   end
550
551   # Check that the user account page will display and contains some relevant
552   # information for the user
553   def test_show
554     # Test a non-existent user
555     get user_path(:display_name => "unknown")
556     assert_response :not_found
557
558     # Test a normal user
559     user = create(:user)
560
561     get user_path(user)
562     assert_response :success
563     assert_select "div#userinformation" do
564       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
565       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
566       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
567       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
568       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
569       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
570       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
571       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
572     end
573
574     # Friends shouldn't be visible as we're not logged in
575     assert_select "div#friends-container", :count => 0
576
577     # Test a user who has been blocked
578     blocked_user = create(:user)
579     create(:user_block, :user => blocked_user)
580     get user_path(blocked_user)
581     assert_response :success
582     assert_select "div#userinformation" do
583       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
584       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
585       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
586       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
587       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
588       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
589       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
590       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
591     end
592
593     # Test a moderator who has applied blocks
594     moderator_user = create(:moderator_user)
595     create(:user_block, :creator => moderator_user)
596     get user_path(moderator_user)
597     assert_response :success
598     assert_select "div#userinformation" do
599       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
600       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
601       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
602       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
603       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
604       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
605       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
606       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
607     end
608
609     # Login as a normal user
610     session_for(user)
611
612     # Test the normal user
613     get user_path(user)
614     assert_response :success
615     assert_select "div#userinformation" do
616       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
617       assert_select "a[href='/traces/mine']", 1
618       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
619       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
620       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 1
621       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
622       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
623       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
624     end
625
626     # Login as a moderator
627     session_for(create(:moderator_user))
628
629     # Test the normal user
630     get user_path(user)
631     assert_response :success
632     assert_select "div#userinformation" do
633       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
634       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
635       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
636       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
637       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
638       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
639       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
640       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
641     end
642   end
643
644   # Test whether information about contributor terms is shown for users who haven't agreed
645   def test_terms_not_agreed
646     agreed_user = create(:user, :terms_agreed => 3.days.ago)
647     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
648     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
649
650     get user_path(agreed_user)
651     assert_response :success
652     assert_select "div#userinformation" do
653       assert_select "dt", :count => 0, :text => /Contributor terms/
654     end
655
656     get user_path(seen_user)
657     assert_response :success
658     # put @response.body
659     assert_select "div#userinformation" do
660       assert_select "dt", :count => 1, :text => /Contributor terms/
661       assert_select "dd", /Declined/
662     end
663
664     get user_path(not_seen_user)
665     assert_response :success
666     assert_select "div#userinformation" do
667       assert_select "dt", :count => 1, :text => /Contributor terms/
668       assert_select "dd", /Undecided/
669     end
670   end
671
672   def test_set_status
673     user = create(:user)
674
675     # Try without logging in
676     post set_status_user_path(user), :params => { :status => "suspended" }
677     assert_response :forbidden
678
679     # Now try as a normal user
680     session_for(user)
681     post set_status_user_path(user), :params => { :status => "suspended" }
682     assert_response :redirect
683     assert_redirected_to :controller => :errors, :action => :forbidden
684
685     # Finally try as an administrator
686     session_for(create(:administrator_user))
687     post set_status_user_path(user), :params => { :status => "suspended" }
688     assert_response :redirect
689     assert_redirected_to :action => :show, :display_name => user.display_name
690     assert_equal "suspended", User.find(user.id).status
691   end
692
693   def test_destroy
694     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
695
696     # Try without logging in
697     delete user_path(user), :params => { :status => "suspended" }
698     assert_response :forbidden
699
700     # Now try as a normal user
701     session_for(user)
702     delete user_path(user), :params => { :status => "suspended" }
703     assert_response :redirect
704     assert_redirected_to :controller => :errors, :action => :forbidden
705
706     # Finally try as an administrator
707     session_for(create(:administrator_user))
708     delete user_path(user), :params => { :status => "suspended" }
709     assert_response :redirect
710     assert_redirected_to :action => :show, :display_name => user.display_name
711
712     # Check that the user was deleted properly
713     user.reload
714     assert_equal "user_#{user.id}", user.display_name
715     assert_equal "", user.description
716     assert_nil user.home_lat
717     assert_nil user.home_lon
718     assert_not user.avatar.attached?
719     assert_not user.email_valid
720     assert_nil user.new_email
721     assert_nil user.auth_provider
722     assert_nil user.auth_uid
723     assert_equal "deleted", user.status
724   end
725
726   def test_index_get
727     user = create(:user)
728     moderator_user = create(:moderator_user)
729     administrator_user = create(:administrator_user)
730     _suspended_user = create(:user, :suspended)
731     _ip_user = create(:user, :creation_ip => "1.2.3.4")
732
733     # There are now 7 users - the five above, plus two extra "granters" for the
734     # moderator_user and administrator_user
735     assert_equal 7, User.count
736
737     # Shouldn't work when not logged in
738     get users_path
739     assert_response :redirect
740     assert_redirected_to login_path(:referer => users_path)
741
742     session_for(user)
743
744     # Shouldn't work when logged in as a normal user
745     get users_path
746     assert_response :redirect
747     assert_redirected_to :controller => :errors, :action => :forbidden
748
749     session_for(moderator_user)
750
751     # Shouldn't work when logged in as a moderator
752     get users_path
753     assert_response :redirect
754     assert_redirected_to :controller => :errors, :action => :forbidden
755
756     session_for(administrator_user)
757
758     # Note there is a header row, so all row counts are users + 1
759     # Should work when logged in as an administrator
760     get users_path
761     assert_response :success
762     assert_template :index
763     assert_select "table#user_list tr", :count => 7 + 1
764
765     # Should be able to limit by status
766     get users_path, :params => { :status => "suspended" }
767     assert_response :success
768     assert_template :index
769     assert_select "table#user_list tr", :count => 1 + 1
770
771     # Should be able to limit by IP address
772     get users_path, :params => { :ip => "1.2.3.4" }
773     assert_response :success
774     assert_template :index
775     assert_select "table#user_list tr", :count => 1 + 1
776   end
777
778   def test_index_get_paginated
779     1.upto(100).each do |n|
780       User.create(:display_name => "extra_#{n}",
781                   :email => "extra#{n}@example.com",
782                   :pass_crypt => "extraextra")
783     end
784
785     session_for(create(:administrator_user))
786
787     # 100 examples, an administrator, and a granter for the admin.
788     assert_equal 102, User.count
789
790     get users_path
791     assert_response :success
792     assert_template :index
793     assert_select "table#user_list tr", :count => 51
794
795     get users_path, :params => { :page => 2 }
796     assert_response :success
797     assert_template :index
798     assert_select "table#user_list tr", :count => 51
799
800     get users_path, :params => { :page => 3 }
801     assert_response :success
802     assert_template :index
803     assert_select "table#user_list tr", :count => 3
804   end
805
806   def test_index_post_confirm
807     inactive_user = create(:user, :pending)
808     suspended_user = create(:user, :suspended)
809
810     # Shouldn't work when not logged in
811     assert_no_difference "User.active.count" do
812       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
813     end
814     assert_response :forbidden
815
816     assert_equal "pending", inactive_user.reload.status
817     assert_equal "suspended", suspended_user.reload.status
818
819     session_for(create(:user))
820
821     # Shouldn't work when logged in as a normal user
822     assert_no_difference "User.active.count" do
823       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
824     end
825     assert_response :redirect
826     assert_redirected_to :controller => :errors, :action => :forbidden
827     assert_equal "pending", inactive_user.reload.status
828     assert_equal "suspended", suspended_user.reload.status
829
830     session_for(create(:moderator_user))
831
832     # Shouldn't work when logged in as a moderator
833     assert_no_difference "User.active.count" do
834       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
835     end
836     assert_response :redirect
837     assert_redirected_to :controller => :errors, :action => :forbidden
838     assert_equal "pending", inactive_user.reload.status
839     assert_equal "suspended", suspended_user.reload.status
840
841     session_for(create(:administrator_user))
842
843     # Should work when logged in as an administrator
844     assert_difference "User.active.count", 2 do
845       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
846     end
847     assert_response :redirect
848     assert_redirected_to :action => :index
849     assert_equal "confirmed", inactive_user.reload.status
850     assert_equal "confirmed", suspended_user.reload.status
851   end
852
853   def test_index_post_hide
854     normal_user = create(:user)
855     confirmed_user = create(:user, :confirmed)
856
857     # Shouldn't work when not logged in
858     assert_no_difference "User.active.count" do
859       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
860     end
861     assert_response :forbidden
862
863     assert_equal "active", normal_user.reload.status
864     assert_equal "confirmed", confirmed_user.reload.status
865
866     session_for(create(:user))
867
868     # Shouldn't work when logged in as a normal user
869     assert_no_difference "User.active.count" do
870       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
871     end
872     assert_response :redirect
873     assert_redirected_to :controller => :errors, :action => :forbidden
874     assert_equal "active", normal_user.reload.status
875     assert_equal "confirmed", confirmed_user.reload.status
876
877     session_for(create(:moderator_user))
878
879     # Shouldn't work when logged in as a moderator
880     assert_no_difference "User.active.count" do
881       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
882     end
883     assert_response :redirect
884     assert_redirected_to :controller => :errors, :action => :forbidden
885     assert_equal "active", normal_user.reload.status
886     assert_equal "confirmed", confirmed_user.reload.status
887
888     session_for(create(:administrator_user))
889
890     # Should work when logged in as an administrator
891     assert_difference "User.active.count", -2 do
892       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
893     end
894     assert_response :redirect
895     assert_redirected_to :action => :index
896     assert_equal "deleted", normal_user.reload.status
897     assert_equal "deleted", confirmed_user.reload.status
898   end
899 end