]> git.openstreetmap.org Git - rails.git/blob - test/controllers/users_controller_test.rb
Merge remote-tracking branch 'upstream/pull/2500'
[rails.git] / test / controllers / users_controller_test.rb
1 require "test_helper"
2
3 class UsersControllerTest < ActionController::TestCase
4   def setup
5     super
6
7     stub_hostip_requests
8   end
9
10   ##
11   # test all routes which lead to this controller
12   def test_routes
13     assert_routing(
14       { :path => "/login", :method => :get },
15       { :controller => "users", :action => "login" }
16     )
17     assert_routing(
18       { :path => "/login", :method => :post },
19       { :controller => "users", :action => "login" }
20     )
21     assert_recognizes(
22       { :controller => "users", :action => "login", :format => "html" },
23       { :path => "/login.html", :method => :get }
24     )
25
26     assert_routing(
27       { :path => "/logout", :method => :get },
28       { :controller => "users", :action => "logout" }
29     )
30     assert_routing(
31       { :path => "/logout", :method => :post },
32       { :controller => "users", :action => "logout" }
33     )
34     assert_recognizes(
35       { :controller => "users", :action => "logout", :format => "html" },
36       { :path => "/logout.html", :method => :get }
37     )
38
39     assert_routing(
40       { :path => "/user/new", :method => :get },
41       { :controller => "users", :action => "new" }
42     )
43
44     assert_routing(
45       { :path => "/user/new", :method => :post },
46       { :controller => "users", :action => "create" }
47     )
48
49     assert_routing(
50       { :path => "/user/terms", :method => :get },
51       { :controller => "users", :action => "terms" }
52     )
53
54     assert_routing(
55       { :path => "/user/save", :method => :post },
56       { :controller => "users", :action => "save" }
57     )
58
59     assert_routing(
60       { :path => "/user/username/confirm", :method => :get },
61       { :controller => "users", :action => "confirm", :display_name => "username" }
62     )
63     assert_routing(
64       { :path => "/user/username/confirm", :method => :post },
65       { :controller => "users", :action => "confirm", :display_name => "username" }
66     )
67     assert_routing(
68       { :path => "/user/username/confirm/resend", :method => :get },
69       { :controller => "users", :action => "confirm_resend", :display_name => "username" }
70     )
71
72     assert_routing(
73       { :path => "/user/confirm", :method => :get },
74       { :controller => "users", :action => "confirm" }
75     )
76     assert_routing(
77       { :path => "/user/confirm", :method => :post },
78       { :controller => "users", :action => "confirm" }
79     )
80     assert_routing(
81       { :path => "/user/confirm-email", :method => :get },
82       { :controller => "users", :action => "confirm_email" }
83     )
84     assert_routing(
85       { :path => "/user/confirm-email", :method => :post },
86       { :controller => "users", :action => "confirm_email" }
87     )
88
89     assert_routing(
90       { :path => "/user/go_public", :method => :post },
91       { :controller => "users", :action => "go_public" }
92     )
93
94     assert_routing(
95       { :path => "/user/forgot-password", :method => :get },
96       { :controller => "users", :action => "lost_password" }
97     )
98     assert_routing(
99       { :path => "/user/forgot-password", :method => :post },
100       { :controller => "users", :action => "lost_password" }
101     )
102     assert_routing(
103       { :path => "/user/reset-password", :method => :get },
104       { :controller => "users", :action => "reset_password" }
105     )
106     assert_routing(
107       { :path => "/user/reset-password", :method => :post },
108       { :controller => "users", :action => "reset_password" }
109     )
110
111     assert_routing(
112       { :path => "/user/suspended", :method => :get },
113       { :controller => "users", :action => "suspended" }
114     )
115
116     assert_routing(
117       { :path => "/user/username", :method => :get },
118       { :controller => "users", :action => "show", :display_name => "username" }
119     )
120
121     assert_routing(
122       { :path => "/user/username/account", :method => :get },
123       { :controller => "users", :action => "account", :display_name => "username" }
124     )
125     assert_routing(
126       { :path => "/user/username/account", :method => :post },
127       { :controller => "users", :action => "account", :display_name => "username" }
128     )
129
130     assert_routing(
131       { :path => "/user/username/make_friend", :method => :get },
132       { :controller => "users", :action => "make_friend", :display_name => "username" }
133     )
134     assert_routing(
135       { :path => "/user/username/make_friend", :method => :post },
136       { :controller => "users", :action => "make_friend", :display_name => "username" }
137     )
138     assert_routing(
139       { :path => "/user/username/remove_friend", :method => :get },
140       { :controller => "users", :action => "remove_friend", :display_name => "username" }
141     )
142     assert_routing(
143       { :path => "/user/username/remove_friend", :method => :post },
144       { :controller => "users", :action => "remove_friend", :display_name => "username" }
145     )
146
147     assert_routing(
148       { :path => "/user/username/set_status", :method => :get },
149       { :controller => "users", :action => "set_status", :display_name => "username" }
150     )
151     assert_routing(
152       { :path => "/user/username/delete", :method => :get },
153       { :controller => "users", :action => "delete", :display_name => "username" }
154     )
155
156     assert_routing(
157       { :path => "/users", :method => :get },
158       { :controller => "users", :action => "index" }
159     )
160     assert_routing(
161       { :path => "/users", :method => :post },
162       { :controller => "users", :action => "index" }
163     )
164     assert_routing(
165       { :path => "/users/status", :method => :get },
166       { :controller => "users", :action => "index", :status => "status" }
167     )
168     assert_routing(
169       { :path => "/users/status", :method => :post },
170       { :controller => "users", :action => "index", :status => "status" }
171     )
172   end
173
174   # The user creation page loads
175   def test_new_view
176     get :new
177     assert_response :redirect
178     assert_redirected_to user_new_path(:cookie_test => "true")
179
180     get :new, :params => { :cookie_test => "true" }, :session => { :cookie_test => true }
181     assert_response :success
182
183     assert_select "html", :count => 1 do
184       assert_select "head", :count => 1 do
185         assert_select "title", :text => /Sign Up/, :count => 1
186       end
187       assert_select "body", :count => 1 do
188         assert_select "div#content", :count => 1 do
189           assert_select "form[action='/user/new'][method='post']", :count => 1 do
190             assert_select "input[id='user_email']", :count => 1
191             assert_select "input[id='user_email_confirmation']", :count => 1
192             assert_select "input[id='user_display_name']", :count => 1
193             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
194             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
195             assert_select "input[type='submit'][value='Sign Up']", :count => 1
196           end
197         end
198       end
199     end
200   end
201
202   def test_new_view_logged_in
203     session[:user] = create(:user).id
204
205     get :new
206     assert_response :redirect
207     assert_redirected_to user_new_path(:cookie_test => "true")
208     get :new, :params => { :cookie_test => "true" }
209     assert_response :redirect
210     assert_redirected_to root_path
211
212     get :new, :params => { :referer => "/test" }
213     assert_response :redirect
214     assert_redirected_to user_new_path(:referer => "/test", :cookie_test => "true")
215     get :new, :params => { :referer => "/test", :cookie_test => "true" }
216     assert_response :redirect
217     assert_redirected_to "/test"
218   end
219
220   def test_new_success
221     user = build(:user, :pending)
222
223     assert_difference "User.count", 1 do
224       assert_difference "ActionMailer::Base.deliveries.size", 1 do
225         perform_enqueued_jobs do
226           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
227         end
228       end
229     end
230
231     # Check the e-mail
232     register_email = ActionMailer::Base.deliveries.first
233
234     assert_equal register_email.to[0], user.email
235     assert_match(/#{@url}/, register_email.body.to_s)
236
237     # Check the page
238     assert_redirected_to :action => "confirm", :display_name => user.display_name
239
240     ActionMailer::Base.deliveries.clear
241   end
242
243   def test_new_duplicate_email
244     user = build(:user, :pending)
245     user.email = create(:user).email
246
247     assert_no_difference "User.count" do
248       assert_no_difference "ActionMailer::Base.deliveries.size" do
249         perform_enqueued_jobs do
250           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
251         end
252       end
253     end
254
255     assert_response :success
256     assert_template "new"
257     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
258   end
259
260   def test_new_duplicate_email_uppercase
261     user = build(:user, :pending)
262     user.email = create(:user).email.upcase
263
264     assert_no_difference "User.count" do
265       assert_no_difference "ActionMailer::Base.deliveries.size" do
266         perform_enqueued_jobs do
267           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
268         end
269       end
270     end
271
272     assert_response :success
273     assert_template "new"
274     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
275   end
276
277   def test_new_duplicate_name
278     user = build(:user, :pending)
279     user.display_name = create(:user).display_name
280
281     assert_no_difference "User.count" do
282       assert_no_difference "ActionMailer::Base.deliveries.size" do
283         perform_enqueued_jobs do
284           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
285         end
286       end
287     end
288
289     assert_response :success
290     assert_template "new"
291     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
292   end
293
294   def test_new_duplicate_name_uppercase
295     user = build(:user, :pending)
296     user.display_name = create(:user).display_name.upcase
297
298     assert_no_difference "User.count" do
299       assert_no_difference "ActionMailer::Base.deliveries.size" do
300         perform_enqueued_jobs do
301           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
302         end
303       end
304     end
305
306     assert_response :success
307     assert_template "new"
308     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
309   end
310
311   def test_new_blocked_domain
312     user = build(:user, :pending, :email => "user@example.net")
313     create(:acl, :domain => "example.net", :k => "no_account_creation")
314
315     assert_no_difference "User.count" do
316       assert_no_difference "ActionMailer::Base.deliveries.size" do
317         perform_enqueued_jobs do
318           post :save, :session => { :new_user => user }, :params => { :read_ct => 1, :read_tou => 1 }
319         end
320       end
321     end
322
323     assert_response :success
324     assert_template "blocked"
325   end
326
327   def test_save_referer_params
328     user = build(:user, :pending)
329
330     assert_difference "User.count", 1 do
331       assert_difference "ActionMailer::Base.deliveries.size", 1 do
332         perform_enqueued_jobs do
333           post :save, :session => { :new_user => user,
334                                     :referer => "/edit?editor=id#map=1/2/3" },
335                       :params => { :read_ct => 1, :read_tou => 1 }
336         end
337       end
338     end
339
340     assert_equal welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3),
341                  user.tokens.order("id DESC").first.referer
342
343     ActionMailer::Base.deliveries.clear
344   end
345
346   def test_logout_without_referer
347     post :logout
348     assert_response :redirect
349     assert_redirected_to root_path
350   end
351
352   def test_logout_with_referer
353     post :logout, :params => { :referer => "/test" }
354     assert_response :redirect
355     assert_redirected_to "/test"
356   end
357
358   def test_logout_fallback_without_referer
359     get :logout
360     assert_response :success
361     assert_template :logout
362     assert_select "input[name=referer][value=?]", ""
363   end
364
365   def test_logout_fallback_with_referer
366     get :logout, :params => { :referer => "/test" }
367     assert_response :success
368     assert_template :logout
369     assert_select "input[name=referer][value=?]", "/test"
370   end
371
372   def test_logout_with_token
373     token = create(:user).tokens.create
374
375     session[:token] = token.token
376
377     post :logout
378     assert_response :redirect
379     assert_redirected_to root_path
380     assert_nil session[:token]
381     assert_nil UserToken.where(:id => token.id).first
382   end
383
384   def test_confirm_get
385     user = create(:user, :pending)
386     confirm_string = user.tokens.create.token
387
388     @request.cookies["_osm_session"] = user.display_name
389     get :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
390     assert_response :success
391     assert_template :confirm
392   end
393
394   def test_confirm_get_already_confirmed
395     user = create(:user)
396     confirm_string = user.tokens.create.token
397
398     @request.cookies["_osm_session"] = user.display_name
399     get :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
400     assert_response :redirect
401     assert_redirected_to root_path
402   end
403
404   def test_confirm_success_no_token_no_referer
405     user = create(:user, :pending)
406     stub_gravatar_request(user.email)
407     confirm_string = user.tokens.create.token
408
409     @request.cookies["_osm_session"] = user.display_name
410     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
411     assert_redirected_to login_path
412     assert_match(/Confirmed your account/, flash[:notice])
413   end
414
415   def test_confirm_success_good_token_no_referer
416     user = create(:user, :pending)
417     stub_gravatar_request(user.email)
418     confirm_string = user.tokens.create.token
419     token = user.tokens.create.token
420
421     @request.cookies["_osm_session"] = user.display_name
422     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
423     assert_redirected_to welcome_path
424   end
425
426   def test_confirm_success_bad_token_no_referer
427     user = create(:user, :pending)
428     stub_gravatar_request(user.email)
429     confirm_string = user.tokens.create.token
430     token = create(:user).tokens.create.token
431
432     @request.cookies["_osm_session"] = user.display_name
433     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
434     assert_redirected_to login_path
435     assert_match(/Confirmed your account/, flash[:notice])
436   end
437
438   def test_confirm_success_no_token_with_referer
439     user = create(:user, :pending)
440     stub_gravatar_request(user.email)
441     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
442
443     @request.cookies["_osm_session"] = user.display_name
444     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
445     assert_redirected_to login_path(:referer => new_diary_entry_path)
446     assert_match(/Confirmed your account/, flash[:notice])
447   end
448
449   def test_confirm_success_good_token_with_referer
450     user = create(:user, :pending)
451     stub_gravatar_request(user.email)
452     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
453     token = user.tokens.create.token
454
455     @request.cookies["_osm_session"] = user.display_name
456     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
457     assert_redirected_to new_diary_entry_path
458   end
459
460   def test_confirm_success_bad_token_with_referer
461     user = create(:user, :pending)
462     stub_gravatar_request(user.email)
463     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
464     token = create(:user).tokens.create.token
465
466     @request.cookies["_osm_session"] = user.display_name
467     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
468     assert_redirected_to login_path(:referer => new_diary_entry_path)
469     assert_match(/Confirmed your account/, flash[:notice])
470   end
471
472   def test_confirm_expired_token
473     user = create(:user, :pending)
474     confirm_string = user.tokens.create(:expiry => 1.day.ago).token
475
476     @request.cookies["_osm_session"] = user.display_name
477     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
478     assert_redirected_to :action => "confirm"
479     assert_match(/confirmation code has expired/, flash[:error])
480   end
481
482   def test_confirm_already_confirmed
483     user = create(:user)
484     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
485
486     @request.cookies["_osm_session"] = user.display_name
487     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
488     assert_redirected_to :action => "login"
489     assert_match(/already been confirmed/, flash[:error])
490   end
491
492   def test_confirm_resend_success
493     user = create(:user, :pending)
494     session[:token] = user.tokens.create.token
495
496     assert_difference "ActionMailer::Base.deliveries.size", 1 do
497       perform_enqueued_jobs do
498         get :confirm_resend, :params => { :display_name => user.display_name }
499       end
500     end
501
502     assert_response :redirect
503     assert_redirected_to login_path
504     assert_match(/sent a new confirmation/, flash[:notice])
505
506     email = ActionMailer::Base.deliveries.last
507
508     assert_equal user.email, email.to.first
509
510     ActionMailer::Base.deliveries.clear
511   end
512
513   def test_confirm_resend_no_token
514     user = create(:user, :pending)
515     assert_no_difference "ActionMailer::Base.deliveries.size" do
516       perform_enqueued_jobs do
517         get :confirm_resend, :params => { :display_name => user.display_name }
518       end
519     end
520
521     assert_response :redirect
522     assert_redirected_to login_path
523     assert_match "User #{user.display_name} not found.", flash[:error]
524   end
525
526   def test_confirm_resend_unknown_user
527     assert_no_difference "ActionMailer::Base.deliveries.size" do
528       perform_enqueued_jobs do
529         get :confirm_resend, :params => { :display_name => "No Such User" }
530       end
531     end
532
533     assert_response :redirect
534     assert_redirected_to login_path
535     assert_match "User No Such User not found.", flash[:error]
536   end
537
538   def test_confirm_email_get
539     user = create(:user)
540     confirm_string = user.tokens.create.token
541
542     get :confirm_email, :params => { :confirm_string => confirm_string }
543     assert_response :success
544     assert_template :confirm_email
545   end
546
547   def test_confirm_email_success
548     user = create(:user, :new_email => "test-new@example.com")
549     stub_gravatar_request(user.new_email)
550     confirm_string = user.tokens.create.token
551
552     post :confirm_email, :params => { :confirm_string => confirm_string }
553     assert_response :redirect
554     assert_redirected_to :action => :account, :display_name => user.display_name
555     assert_match(/Confirmed your change of email address/, flash[:notice])
556   end
557
558   def test_confirm_email_already_confirmed
559     user = create(:user)
560     confirm_string = user.tokens.create.token
561
562     post :confirm_email, :params => { :confirm_string => confirm_string }
563     assert_response :redirect
564     assert_redirected_to :action => :account, :display_name => user.display_name
565     assert_match(/already been confirmed/, flash[:error])
566   end
567
568   def test_confirm_email_bad_token
569     post :confirm_email, :params => { :confirm_string => "XXXXX" }
570     assert_response :success
571     assert_template :confirm_email
572     assert_match(/confirmation code has expired or does not exist/, flash[:error])
573   end
574
575   ##
576   # test if testing for a gravatar works
577   # this happens when the email is actually changed
578   # which is triggered by the confirmation mail
579   def test_gravatar_auto_enable
580     # switch to email that has a gravatar
581     user = create(:user, :new_email => "test-new@example.com")
582     stub_gravatar_request(user.new_email, 200)
583     confirm_string = user.tokens.create.token
584     # precondition gravatar should be turned off
585     assert_not user.image_use_gravatar
586     post :confirm_email, :params => { :confirm_string => confirm_string }
587     assert_response :redirect
588     assert_redirected_to :action => :account, :display_name => user.display_name
589     assert_match(/Confirmed your change of email address/, flash[:notice])
590     # gravatar use should now be enabled
591     assert User.find(user.id).image_use_gravatar
592   end
593
594   def test_gravatar_auto_disable
595     # switch to email without a gravatar
596     user = create(:user, :new_email => "test-new@example.com", :image_use_gravatar => true)
597     stub_gravatar_request(user.new_email, 404)
598     confirm_string = user.tokens.create.token
599     # precondition gravatar should be turned on
600     assert user.image_use_gravatar
601     post :confirm_email, :params => { :confirm_string => confirm_string }
602     assert_response :redirect
603     assert_redirected_to :action => :account, :display_name => user.display_name
604     assert_match(/Confirmed your change of email address/, flash[:notice])
605     # gravatar use should now be disabled
606     assert_not User.find(user.id).image_use_gravatar
607   end
608
609   def test_terms_new_user
610     get :terms, :session => { :new_user => User.new }
611     assert_response :success
612     assert_template :terms
613   end
614
615   def test_terms_agreed
616     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
617
618     session[:user] = user.id
619
620     get :terms
621     assert_response :redirect
622     assert_redirected_to :action => :account, :display_name => user.display_name
623   end
624
625   def test_terms_not_seen_without_referer
626     user = create(:user, :terms_seen => false, :terms_agreed => nil)
627
628     session[:user] = user.id
629
630     get :terms
631     assert_response :success
632     assert_template :terms
633
634     post :save, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
635     assert_response :redirect
636     assert_redirected_to :action => :account, :display_name => user.display_name
637     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
638
639     user.reload
640
641     assert_equal true, user.consider_pd
642     assert_not_nil user.terms_agreed
643     assert_equal true, user.terms_seen
644   end
645
646   def test_terms_not_seen_with_referer
647     user = create(:user, :terms_seen => false, :terms_agreed => nil)
648
649     session[:user] = user.id
650
651     get :terms, :params => { :referer => "/test" }
652     assert_response :success
653     assert_template :terms
654
655     post :save, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
656     assert_response :redirect
657     assert_redirected_to "/test"
658     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
659
660     user.reload
661
662     assert_equal true, user.consider_pd
663     assert_not_nil user.terms_agreed
664     assert_equal true, user.terms_seen
665   end
666
667   # Check that if you haven't seen the terms, and make a request that requires authentication,
668   # that your request is redirected to view the terms
669   def test_terms_not_seen_redirection
670     user = create(:user, :terms_seen => false, :terms_agreed => nil)
671     session[:user] = user.id
672
673     get :account, :params => { :display_name => user.display_name }
674     assert_response :redirect
675     assert_redirected_to :action => :terms, :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
676   end
677
678   def test_go_public
679     user = create(:user, :data_public => false)
680     post :go_public, :session => { :user => user }
681     assert_response :redirect
682     assert_redirected_to :action => :account, :display_name => user.display_name
683     assert_equal true, User.find(user.id).data_public
684   end
685
686   def test_lost_password
687     # Test fetching the lost password page
688     get :lost_password
689     assert_response :success
690     assert_template :lost_password
691     assert_select "div#notice", false
692
693     # Test resetting using the address as recorded for a user that has an
694     # address which is duplicated in a different case by another user
695     user = create(:user)
696     uppercase_user = build(:user, :email => user.email.upcase).tap { |u| u.save(:validate => false) }
697
698     assert_difference "ActionMailer::Base.deliveries.size", 1 do
699       perform_enqueued_jobs do
700         post :lost_password, :params => { :user => { :email => user.email } }
701       end
702     end
703     assert_response :redirect
704     assert_redirected_to :action => :login
705     assert_match(/^Sorry you lost it/, flash[:notice])
706     email = ActionMailer::Base.deliveries.first
707     assert_equal 1, email.to.count
708     assert_equal user.email, email.to.first
709     ActionMailer::Base.deliveries.clear
710
711     # Test resetting using an address that matches a different user
712     # that has the same address in a different case
713     assert_difference "ActionMailer::Base.deliveries.size", 1 do
714       perform_enqueued_jobs do
715         post :lost_password, :params => { :user => { :email => user.email.upcase } }
716       end
717     end
718     assert_response :redirect
719     assert_redirected_to :action => :login
720     assert_match(/^Sorry you lost it/, flash[:notice])
721     email = ActionMailer::Base.deliveries.first
722     assert_equal 1, email.to.count
723     assert_equal uppercase_user.email, email.to.first
724     ActionMailer::Base.deliveries.clear
725
726     # Test resetting using an address that is a case insensitive match
727     # for more than one user but not an exact match for either
728     assert_no_difference "ActionMailer::Base.deliveries.size" do
729       perform_enqueued_jobs do
730         post :lost_password, :params => { :user => { :email => user.email.titlecase } }
731       end
732     end
733     assert_response :success
734     assert_template :lost_password
735     assert_select ".error", /^Could not find that email address/
736
737     # Test resetting using the address as recorded for a user that has an
738     # address which is case insensitively unique
739     third_user = create(:user)
740     assert_difference "ActionMailer::Base.deliveries.size", 1 do
741       perform_enqueued_jobs do
742         post :lost_password, :params => { :user => { :email => third_user.email } }
743       end
744     end
745     assert_response :redirect
746     assert_redirected_to :action => :login
747     assert_match(/^Sorry you lost it/, flash[:notice])
748     email = ActionMailer::Base.deliveries.first
749     assert_equal 1, email.to.count
750     assert_equal third_user.email, email.to.first
751     ActionMailer::Base.deliveries.clear
752
753     # Test resetting using an address that matches a user that has the
754     # same (case insensitively unique) address in a different case
755     assert_difference "ActionMailer::Base.deliveries.size", 1 do
756       perform_enqueued_jobs do
757         post :lost_password, :params => { :user => { :email => third_user.email.upcase } }
758       end
759     end
760     assert_response :redirect
761     assert_redirected_to :action => :login
762     assert_match(/^Sorry you lost it/, flash[:notice])
763     email = ActionMailer::Base.deliveries.first
764     assert_equal 1, email.to.count
765     assert_equal third_user.email, email.to.first
766     ActionMailer::Base.deliveries.clear
767   end
768
769   def test_reset_password
770     user = create(:user, :pending)
771     # Test a request with no token
772     get :reset_password
773     assert_response :bad_request
774
775     # Test a request with a bogus token
776     get :reset_password, :params => { :token => "made_up_token" }
777     assert_response :redirect
778     assert_redirected_to :action => :lost_password
779
780     # Create a valid token for a user
781     token = user.tokens.create
782
783     # Test a request with a valid token
784     get :reset_password, :params => { :token => token.token }
785     assert_response :success
786     assert_template :reset_password
787
788     # Test that errors are reported for erroneous submissions
789     post :reset_password, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "different_password" } }
790     assert_response :success
791     assert_template :reset_password
792     assert_select "div#errorExplanation"
793
794     # Test setting a new password
795     post :reset_password, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "new_password" } }
796     assert_response :redirect
797     assert_redirected_to root_path
798     assert_equal user.id, session[:user]
799     user.reload
800     assert_equal "active", user.status
801     assert_equal true, user.email_valid
802     assert_equal user, User.authenticate(:username => user.email, :password => "new_password")
803   end
804
805   def test_account
806     # Get a user to work with - note that this user deliberately
807     # conflicts with uppercase_user in the email and display name
808     # fields to test that we can change other fields without any
809     # validation errors being reported
810     user = create(:user, :languages => [])
811     _uppercase_user = build(:user, :email => user.email.upcase, :display_name => user.display_name.upcase).tap { |u| u.save(:validate => false) }
812
813     # Make sure that you are redirected to the login page when
814     # you are not logged in
815     get :account, :params => { :display_name => user.display_name }
816     assert_response :redirect
817     assert_redirected_to :action => "login", :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
818
819     # Make sure that you are blocked when not logged in as the right user
820     get :account, :params => { :display_name => user.display_name }, :session => { :user => create(:user) }
821     assert_response :forbidden
822
823     # Make sure we get the page when we are logged in as the right user
824     get :account, :params => { :display_name => user.display_name }, :session => { :user => user }
825     assert_response :success
826     assert_template :account
827     assert_select "form#accountForm" do |form|
828       assert_equal "post", form.attr("method").to_s
829       assert_select "input[name='_method']", false
830       assert_equal "/user/#{ERB::Util.u(user.display_name)}/account", form.attr("action").to_s
831     end
832
833     # Updating the description should work
834     user.description = "new description"
835     user.preferred_editor = "default"
836     post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
837     assert_response :success
838     assert_template :account
839     assert_select "div#errorExplanation", false
840     assert_select ".notice", /^User information updated successfully/
841     assert_select "form#accountForm > fieldset > div.form-row > div#user_description_container > div#user_description_content > textarea#user_description", user.description
842
843     # Changing to a invalid editor should fail
844     user.preferred_editor = "unknown"
845     post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
846     assert_response :success
847     assert_template :account
848     assert_select ".notice", false
849     assert_select "div#errorExplanation"
850     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected]", false
851
852     # Changing to a valid editor should work
853     user.preferred_editor = "potlatch2"
854     post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
855     assert_response :success
856     assert_template :account
857     assert_select "div#errorExplanation", false
858     assert_select ".notice", /^User information updated successfully/
859     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected][value=?]", "potlatch2"
860
861     # Changing to the default editor should work
862     user.preferred_editor = "default"
863     post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
864     assert_response :success
865     assert_template :account
866     assert_select "div#errorExplanation", false
867     assert_select ".notice", /^User information updated successfully/
868     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected]", false
869
870     # Changing to an uploaded image should work
871     image = Rack::Test::UploadedFile.new("test/gpx/fixtures/a.gif", "image/gif")
872     post :account, :params => { :display_name => user.display_name, :avatar_action => "new", :user => user.attributes.merge(:avatar => image) }, :session => { :user => user }
873     assert_response :success
874     assert_template :account
875     assert_select "div#errorExplanation", false
876     assert_select ".notice", /^User information updated successfully/
877     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked][value=?]", "keep"
878
879     # Changing to a gravatar image should work
880     post :account, :params => { :display_name => user.display_name, :avatar_action => "gravatar", :user => user.attributes }, :session => { :user => user }
881     assert_response :success
882     assert_template :account
883     assert_select "div#errorExplanation", false
884     assert_select ".notice", /^User information updated successfully/
885     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked][value=?]", "gravatar"
886
887     # Removing the image should work
888     post :account, :params => { :display_name => user.display_name, :avatar_action => "delete", :user => user.attributes }, :session => { :user => user }
889     assert_response :success
890     assert_template :account
891     assert_select "div#errorExplanation", false
892     assert_select ".notice", /^User information updated successfully/
893     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked]", false
894
895     # Adding external authentication should redirect to the auth provider
896     post :account, :params => { :display_name => user.display_name, :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }, :session => { :user => user }
897     assert_response :redirect
898     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")
899
900     # Changing name to one that exists should fail
901     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name)
902     post :account, :params => { :display_name => user.display_name, :user => new_attributes }, :session => { :user => user }
903     assert_response :success
904     assert_template :account
905     assert_select ".notice", false
906     assert_select "div#errorExplanation"
907     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
908
909     # Changing name to one that exists should fail, regardless of case
910     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name.upcase)
911     post :account, :params => { :display_name => user.display_name, :user => new_attributes }, :session => { :user => user }
912     assert_response :success
913     assert_template :account
914     assert_select ".notice", false
915     assert_select "div#errorExplanation"
916     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
917
918     # Changing name to one that doesn't exist should work
919     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
920     post :account, :params => { :display_name => user.display_name, :user => new_attributes }, :session => { :user => user }
921     assert_response :success
922     assert_template :account
923     assert_select "div#errorExplanation", false
924     assert_select ".notice", /^User information updated successfully/
925     assert_select "form#accountForm > fieldset > div.form-row > input#user_display_name[value=?]", "new tester"
926
927     # Record the change of name
928     user.display_name = "new tester"
929
930     # Changing email to one that exists should fail
931     user.new_email = create(:user).email
932     assert_no_difference "ActionMailer::Base.deliveries.size" do
933       perform_enqueued_jobs do
934         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
935       end
936     end
937     assert_response :success
938     assert_template :account
939     assert_select ".notice", false
940     assert_select "div#errorExplanation"
941     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
942
943     # Changing email to one that exists should fail, regardless of case
944     user.new_email = create(:user).email.upcase
945     assert_no_difference "ActionMailer::Base.deliveries.size" do
946       perform_enqueued_jobs do
947         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
948       end
949     end
950     assert_response :success
951     assert_template :account
952     assert_select ".notice", false
953     assert_select "div#errorExplanation"
954     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
955
956     # Changing email to one that doesn't exist should work
957     user.new_email = "new_tester@example.com"
958     assert_difference "ActionMailer::Base.deliveries.size", 1 do
959       perform_enqueued_jobs do
960         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
961       end
962     end
963     assert_response :success
964     assert_template :account
965     assert_select "div#errorExplanation", false
966     assert_select ".notice", /^User information updated successfully/
967     assert_select "form#accountForm > fieldset > div.form-row > input#user_new_email[value=?]", user.new_email
968     email = ActionMailer::Base.deliveries.first
969     assert_equal 1, email.to.count
970     assert_equal user.new_email, email.to.first
971     ActionMailer::Base.deliveries.clear
972   end
973
974   # Check that the user account page will display and contains some relevant
975   # information for the user
976   def test_show
977     # Test a non-existent user
978     get :show, :params => { :display_name => "unknown" }
979     assert_response :not_found
980
981     # Test a normal user
982     user = create(:user, :home_lon => 1.1, :home_lat => 1.1)
983     friend_user = create(:user, :home_lon => 1.2, :home_lat => 1.2)
984     create(:friendship, :befriender => user, :befriendee => friend_user)
985     create(:changeset, :user => friend_user)
986
987     get :show, :params => { :display_name => user.display_name }
988     assert_response :success
989     assert_select "div#userinformation" do
990       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
991       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
992       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
993       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
994       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
995       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
996       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
997       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
998     end
999
1000     # Friends shouldn't be visible as we're not logged in
1001     assert_select "div#friends-container", :count => 0
1002
1003     # Test a user who has been blocked
1004     blocked_user = create(:user)
1005     create(:user_block, :user => blocked_user)
1006     get :show, :params => { :display_name => blocked_user.display_name }
1007     assert_response :success
1008     assert_select "div#userinformation" do
1009       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
1010       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
1011       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
1012       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
1013       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
1014       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
1015       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
1016       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
1017     end
1018
1019     # Test a moderator who has applied blocks
1020     moderator_user = create(:moderator_user)
1021     create(:user_block, :creator => moderator_user)
1022     get :show, :params => { :display_name => moderator_user.display_name }
1023     assert_response :success
1024     assert_select "div#userinformation" do
1025       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
1026       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
1027       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
1028       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
1029       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
1030       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
1031       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
1032       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
1033     end
1034
1035     # Login as a normal user
1036     session[:user] = user.id
1037
1038     # Test the normal user
1039     get :show, :params => { :display_name => user.display_name }
1040     assert_response :success
1041     assert_select "div#userinformation" do
1042       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1043       assert_select "a[href='/traces/mine']", 1
1044       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1045       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1046       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 1
1047       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1048       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1049       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
1050     end
1051
1052     # Friends should be visible as we're now logged in
1053     assert_select "div#friends-container" do
1054       assert_select "div.contact-activity", :count => 1
1055     end
1056
1057     # Login as a moderator
1058     session[:user] = create(:moderator_user).id
1059
1060     # Test the normal user
1061     get :show, :params => { :display_name => user.display_name }
1062     assert_response :success
1063     assert_select "div#userinformation" do
1064       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1065       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
1066       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1067       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1068       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
1069       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1070       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1071       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
1072     end
1073   end
1074
1075   # Test whether information about contributor terms is shown for users who haven't agreed
1076   def test_terms_not_agreed
1077     agreed_user = create(:user, :terms_agreed => 3.days.ago)
1078     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
1079     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
1080
1081     get :show, :params => { :display_name => agreed_user.display_name }
1082     assert_response :success
1083     assert_select "div#userinformation" do
1084       assert_select "p", :count => 0, :text => /Contributor terms/
1085     end
1086
1087     get :show, :params => { :display_name => seen_user.display_name }
1088     assert_response :success
1089     # put @response.body
1090     assert_select "div#userinformation" do
1091       assert_select "p", :count => 1, :text => /Contributor terms/
1092       assert_select "p", /Declined/
1093     end
1094
1095     get :show, :params => { :display_name => not_seen_user.display_name }
1096     assert_response :success
1097     assert_select "div#userinformation" do
1098       assert_select "p", :count => 1, :text => /Contributor terms/
1099       assert_select "p", /Undecided/
1100     end
1101   end
1102
1103   def test_make_friend
1104     # Get users to work with
1105     user = create(:user)
1106     friend = create(:user)
1107
1108     # Check that the users aren't already friends
1109     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1110
1111     # When not logged in a GET should ask us to login
1112     get :make_friend, :params => { :display_name => friend.display_name }
1113     assert_redirected_to :action => "login", :referer => make_friend_path(:display_name => friend.display_name)
1114
1115     # When not logged in a POST should error
1116     post :make_friend, :params => { :display_name => friend.display_name }
1117     assert_response :forbidden
1118     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1119
1120     # When logged in a GET should get a confirmation page
1121     get :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1122     assert_response :success
1123     assert_template :make_friend
1124     assert_select "form" do
1125       assert_select "input[type='hidden'][name='referer']", 0
1126       assert_select "input[type='submit']", 1
1127     end
1128     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1129
1130     # When logged in a POST should add the friendship
1131     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1132       perform_enqueued_jobs do
1133         post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1134       end
1135     end
1136     assert_redirected_to user_path(friend)
1137     assert_match(/is now your friend/, flash[:notice])
1138     assert Friendship.where(:befriender => user, :befriendee => friend).first
1139     email = ActionMailer::Base.deliveries.first
1140     assert_equal 1, email.to.count
1141     assert_equal friend.email, email.to.first
1142     ActionMailer::Base.deliveries.clear
1143
1144     # A second POST should report that the friendship already exists
1145     assert_no_difference "ActionMailer::Base.deliveries.size" do
1146       perform_enqueued_jobs do
1147         post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1148       end
1149     end
1150     assert_redirected_to user_path(friend)
1151     assert_match(/You are already friends with/, flash[:warning])
1152     assert Friendship.where(:befriender => user, :befriendee => friend).first
1153   end
1154
1155   def test_make_friend_with_referer
1156     # Get users to work with
1157     user = create(:user)
1158     friend = create(:user)
1159
1160     # Check that the users aren't already friends
1161     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1162
1163     # The GET should preserve any referer
1164     get :make_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1165     assert_response :success
1166     assert_template :make_friend
1167     assert_select "form" do
1168       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1169       assert_select "input[type='submit']", 1
1170     end
1171     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1172
1173     # When logged in a POST should add the friendship and refer us
1174     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1175       perform_enqueued_jobs do
1176         post :make_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1177       end
1178     end
1179     assert_redirected_to "/test"
1180     assert_match(/is now your friend/, flash[:notice])
1181     assert Friendship.where(:befriender => user, :befriendee => friend).first
1182     email = ActionMailer::Base.deliveries.first
1183     assert_equal 1, email.to.count
1184     assert_equal friend.email, email.to.first
1185     ActionMailer::Base.deliveries.clear
1186   end
1187
1188   def test_make_friend_unkown_user
1189     # Should error when a bogus user is specified
1190     get :make_friend, :params => { :display_name => "No Such User" }, :session => { :user => create(:user) }
1191     assert_response :not_found
1192     assert_template :no_such_user
1193   end
1194
1195   def test_remove_friend
1196     # Get users to work with
1197     user = create(:user)
1198     friend = create(:user)
1199     create(:friendship, :befriender => user, :befriendee => friend)
1200
1201     # Check that the users are friends
1202     assert Friendship.where(:befriender => user, :befriendee => friend).first
1203
1204     # When not logged in a GET should ask us to login
1205     get :remove_friend, :params => { :display_name => friend.display_name }
1206     assert_redirected_to :action => "login", :referer => remove_friend_path(:display_name => friend.display_name)
1207
1208     # When not logged in a POST should error
1209     post :remove_friend, :params => { :display_name => friend.display_name }
1210     assert_response :forbidden
1211     assert Friendship.where(:befriender => user, :befriendee => friend).first
1212
1213     # When logged in a GET should get a confirmation page
1214     get :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1215     assert_response :success
1216     assert_template :remove_friend
1217     assert_select "form" do
1218       assert_select "input[type='hidden'][name='referer']", 0
1219       assert_select "input[type='submit']", 1
1220     end
1221     assert Friendship.where(:befriender => user, :befriendee => friend).first
1222
1223     # When logged in a POST should remove the friendship
1224     post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1225     assert_redirected_to user_path(friend)
1226     assert_match(/was removed from your friends/, flash[:notice])
1227     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1228
1229     # A second POST should report that the friendship does not exist
1230     post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1231     assert_redirected_to user_path(friend)
1232     assert_match(/is not one of your friends/, flash[:error])
1233     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1234   end
1235
1236   def test_remove_friend_with_referer
1237     # Get users to work with
1238     user = create(:user)
1239     friend = create(:user)
1240     create(:friendship, :befriender => user, :befriendee => friend)
1241
1242     # Check that the users are friends
1243     assert Friendship.where(:befriender => user, :befriendee => friend).first
1244
1245     # The GET should preserve any referer
1246     get :remove_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1247     assert_response :success
1248     assert_template :remove_friend
1249     assert_select "form" do
1250       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1251       assert_select "input[type='submit']", 1
1252     end
1253     assert Friendship.where(:befriender => user, :befriendee => friend).first
1254
1255     # When logged in a POST should remove the friendship and refer
1256     post :remove_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1257     assert_redirected_to "/test"
1258     assert_match(/was removed from your friends/, flash[:notice])
1259     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1260   end
1261
1262   def test_remove_friend_unkown_user
1263     # Should error when a bogus user is specified
1264     get :remove_friend, :params => { :display_name => "No Such User" }, :session => { :user => create(:user) }
1265     assert_response :not_found
1266     assert_template :no_such_user
1267   end
1268
1269   def test_set_status
1270     user = create(:user)
1271
1272     # Try without logging in
1273     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }
1274     assert_response :redirect
1275     assert_redirected_to :action => :login, :referer => set_status_user_path(:status => "suspended")
1276
1277     # Now try as a normal user
1278     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => user }
1279     assert_response :redirect
1280     assert_redirected_to :controller => :errors, :action => :forbidden
1281
1282     # Finally try as an administrator
1283     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => create(:administrator_user) }
1284     assert_response :redirect
1285     assert_redirected_to :action => :show, :display_name => user.display_name
1286     assert_equal "suspended", User.find(user.id).status
1287   end
1288
1289   def test_delete
1290     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
1291
1292     # Try without logging in
1293     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }
1294     assert_response :redirect
1295     assert_redirected_to :action => :login, :referer => delete_user_path(:status => "suspended")
1296
1297     # Now try as a normal user
1298     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => user }
1299     assert_response :redirect
1300     assert_redirected_to :controller => :errors, :action => :forbidden
1301
1302     # Finally try as an administrator
1303     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => create(:administrator_user) }
1304     assert_response :redirect
1305     assert_redirected_to :action => :show, :display_name => user.display_name
1306
1307     # Check that the user was deleted properly
1308     user.reload
1309     assert_equal "user_#{user.id}", user.display_name
1310     assert_equal "", user.description
1311     assert_nil user.home_lat
1312     assert_nil user.home_lon
1313     assert_equal false, user.avatar.attached?
1314     assert_equal false, user.email_valid
1315     assert_nil user.new_email
1316     assert_nil user.auth_provider
1317     assert_nil user.auth_uid
1318     assert_equal "deleted", user.status
1319   end
1320
1321   def test_index_get
1322     user = create(:user)
1323     moderator_user = create(:moderator_user)
1324     administrator_user = create(:administrator_user)
1325     _suspended_user = create(:user, :suspended)
1326     _ip_user = create(:user, :creation_ip => "1.2.3.4")
1327
1328     # There are now 7 users - the five above, plus two extra "granters" for the
1329     # moderator_user and administrator_user
1330     assert_equal 7, User.count
1331
1332     # Shouldn't work when not logged in
1333     get :index
1334     assert_response :redirect
1335     assert_redirected_to :action => :login, :referer => users_path
1336
1337     session[:user] = user.id
1338
1339     # Shouldn't work when logged in as a normal user
1340     get :index
1341     assert_response :redirect
1342     assert_redirected_to :controller => :errors, :action => :forbidden
1343
1344     session[:user] = moderator_user.id
1345
1346     # Shouldn't work when logged in as a moderator
1347     get :index
1348     assert_response :redirect
1349     assert_redirected_to :controller => :errors, :action => :forbidden
1350
1351     session[:user] = administrator_user.id
1352
1353     # Note there is a header row, so all row counts are users + 1
1354     # Should work when logged in as an administrator
1355     get :index
1356     assert_response :success
1357     assert_template :index
1358     assert_select "table#user_list tr", :count => 7 + 1
1359
1360     # Should be able to limit by status
1361     get :index, :params => { :status => "suspended" }
1362     assert_response :success
1363     assert_template :index
1364     assert_select "table#user_list tr", :count => 1 + 1
1365
1366     # Should be able to limit by IP address
1367     get :index, :params => { :ip => "1.2.3.4" }
1368     assert_response :success
1369     assert_template :index
1370     assert_select "table#user_list tr", :count => 1 + 1
1371   end
1372
1373   def test_index_get_paginated
1374     1.upto(100).each do |n|
1375       User.create(:display_name => "extra_#{n}",
1376                   :email => "extra#{n}@example.com",
1377                   :pass_crypt => "extraextra")
1378     end
1379
1380     session[:user] = create(:administrator_user).id
1381
1382     # 100 examples, an administrator, and a granter for the admin.
1383     assert_equal 102, User.count
1384
1385     get :index
1386     assert_response :success
1387     assert_template :index
1388     assert_select "table#user_list tr", :count => 51
1389
1390     get :index, :params => { :page => 2 }
1391     assert_response :success
1392     assert_template :index
1393     assert_select "table#user_list tr", :count => 51
1394
1395     get :index, :params => { :page => 3 }
1396     assert_response :success
1397     assert_template :index
1398     assert_select "table#user_list tr", :count => 3
1399   end
1400
1401   def test_index_post_confirm
1402     inactive_user = create(:user, :pending)
1403     suspended_user = create(:user, :suspended)
1404
1405     # Shouldn't work when not logged in
1406     assert_no_difference "User.active.count" do
1407       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1408     end
1409     assert_response :forbidden
1410
1411     assert_equal "pending", inactive_user.reload.status
1412     assert_equal "suspended", suspended_user.reload.status
1413
1414     session[:user] = create(:user).id
1415
1416     # Shouldn't work when logged in as a normal user
1417     assert_no_difference "User.active.count" do
1418       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1419     end
1420     assert_response :redirect
1421     assert_redirected_to :controller => :errors, :action => :forbidden
1422     assert_equal "pending", inactive_user.reload.status
1423     assert_equal "suspended", suspended_user.reload.status
1424
1425     session[:user] = create(:moderator_user).id
1426
1427     # Shouldn't work when logged in as a moderator
1428     assert_no_difference "User.active.count" do
1429       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1430     end
1431     assert_response :redirect
1432     assert_redirected_to :controller => :errors, :action => :forbidden
1433     assert_equal "pending", inactive_user.reload.status
1434     assert_equal "suspended", suspended_user.reload.status
1435
1436     session[:user] = create(:administrator_user).id
1437
1438     # Should work when logged in as an administrator
1439     assert_difference "User.active.count", 2 do
1440       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1441     end
1442     assert_response :redirect
1443     assert_redirected_to :action => :index
1444     assert_equal "confirmed", inactive_user.reload.status
1445     assert_equal "confirmed", suspended_user.reload.status
1446   end
1447
1448   def test_index_post_hide
1449     normal_user = create(:user)
1450     confirmed_user = create(:user, :confirmed)
1451
1452     # Shouldn't work when not logged in
1453     assert_no_difference "User.active.count" do
1454       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1455     end
1456     assert_response :forbidden
1457
1458     assert_equal "active", normal_user.reload.status
1459     assert_equal "confirmed", confirmed_user.reload.status
1460
1461     session[:user] = create(:user).id
1462
1463     # Shouldn't work when logged in as a normal user
1464     assert_no_difference "User.active.count" do
1465       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1466     end
1467     assert_response :redirect
1468     assert_redirected_to :controller => :errors, :action => :forbidden
1469     assert_equal "active", normal_user.reload.status
1470     assert_equal "confirmed", confirmed_user.reload.status
1471
1472     session[:user] = create(:moderator_user).id
1473
1474     # Shouldn't work when logged in as a moderator
1475     assert_no_difference "User.active.count" do
1476       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1477     end
1478     assert_response :redirect
1479     assert_redirected_to :controller => :errors, :action => :forbidden
1480     assert_equal "active", normal_user.reload.status
1481     assert_equal "confirmed", confirmed_user.reload.status
1482
1483     session[:user] = create(:administrator_user).id
1484
1485     # Should work when logged in as an administrator
1486     assert_difference "User.active.count", -2 do
1487       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1488     end
1489     assert_response :redirect
1490     assert_redirected_to :action => :index
1491     assert_equal "deleted", normal_user.reload.status
1492     assert_equal "deleted", confirmed_user.reload.status
1493   end
1494 end