Use correct link for settings page
[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     get :logout
348     assert_response :success
349     assert_template :logout
350     assert_select "input[name=referer][value=?]", ""
351
352     session_id = assert_select("input[name=session]").first["value"]
353
354     get :logout, :params => { :session => session_id }
355     assert_response :redirect
356     assert_redirected_to root_path
357   end
358
359   def test_logout_with_referer
360     get :logout, :params => { :referer => "/test" }
361     assert_response :success
362     assert_template :logout
363     assert_select "input[name=referer][value=?]", "/test"
364
365     session_id = assert_select("input[name=session]").first["value"]
366
367     get :logout, :params => { :session => session_id, :referer => "/test" }
368     assert_response :redirect
369     assert_redirected_to "/test"
370   end
371
372   def test_logout_with_token
373     token = create(:user).tokens.create
374
375     session[:token] = token.token
376
377     get :logout
378     assert_response :success
379     assert_template :logout
380     assert_select "input[name=referer][value=?]", ""
381     assert_equal token.token, session[:token]
382     assert_not_nil UserToken.where(:id => token.id).first
383
384     session_id = assert_select("input[name=session]").first["value"]
385
386     get :logout, :params => { :session => session_id }
387     assert_response :redirect
388     assert_redirected_to root_path
389     assert_nil session[:token]
390     assert_nil UserToken.where(:id => token.id).first
391   end
392
393   def test_confirm_get
394     user = create(:user, :pending)
395     confirm_string = user.tokens.create.token
396
397     @request.cookies["_osm_session"] = user.display_name
398     get :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
399     assert_response :success
400     assert_template :confirm
401   end
402
403   def test_confirm_get_already_confirmed
404     user = create(:user)
405     confirm_string = user.tokens.create.token
406
407     @request.cookies["_osm_session"] = user.display_name
408     get :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
409     assert_response :redirect
410     assert_redirected_to root_path
411   end
412
413   def test_confirm_success_no_token_no_referer
414     user = create(:user, :pending)
415     stub_gravatar_request(user.email)
416     confirm_string = user.tokens.create.token
417
418     @request.cookies["_osm_session"] = user.display_name
419     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
420     assert_redirected_to login_path
421     assert_match(/Confirmed your account/, flash[:notice])
422   end
423
424   def test_confirm_success_good_token_no_referer
425     user = create(:user, :pending)
426     stub_gravatar_request(user.email)
427     confirm_string = user.tokens.create.token
428     token = user.tokens.create.token
429
430     @request.cookies["_osm_session"] = user.display_name
431     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
432     assert_redirected_to welcome_path
433   end
434
435   def test_confirm_success_bad_token_no_referer
436     user = create(:user, :pending)
437     stub_gravatar_request(user.email)
438     confirm_string = user.tokens.create.token
439     token = create(:user).tokens.create.token
440
441     @request.cookies["_osm_session"] = user.display_name
442     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
443     assert_redirected_to login_path
444     assert_match(/Confirmed your account/, flash[:notice])
445   end
446
447   def test_confirm_success_no_token_with_referer
448     user = create(:user, :pending)
449     stub_gravatar_request(user.email)
450     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
451
452     @request.cookies["_osm_session"] = user.display_name
453     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
454     assert_redirected_to login_path(:referer => new_diary_entry_path)
455     assert_match(/Confirmed your account/, flash[:notice])
456   end
457
458   def test_confirm_success_good_token_with_referer
459     user = create(:user, :pending)
460     stub_gravatar_request(user.email)
461     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
462     token = user.tokens.create.token
463
464     @request.cookies["_osm_session"] = user.display_name
465     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
466     assert_redirected_to new_diary_entry_path
467   end
468
469   def test_confirm_success_bad_token_with_referer
470     user = create(:user, :pending)
471     stub_gravatar_request(user.email)
472     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
473     token = create(:user).tokens.create.token
474
475     @request.cookies["_osm_session"] = user.display_name
476     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
477     assert_redirected_to login_path(:referer => new_diary_entry_path)
478     assert_match(/Confirmed your account/, flash[:notice])
479   end
480
481   def test_confirm_expired_token
482     user = create(:user, :pending)
483     confirm_string = user.tokens.create(:expiry => 1.day.ago).token
484
485     @request.cookies["_osm_session"] = user.display_name
486     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
487     assert_redirected_to :action => "confirm"
488     assert_match(/confirmation code has expired/, flash[:error])
489   end
490
491   def test_confirm_already_confirmed
492     user = create(:user)
493     confirm_string = user.tokens.create(:referer => new_diary_entry_path).token
494
495     @request.cookies["_osm_session"] = user.display_name
496     post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
497     assert_redirected_to :action => "login"
498     assert_match(/already been confirmed/, flash[:error])
499   end
500
501   def test_confirm_resend_success
502     user = create(:user, :pending)
503     session[:token] = user.tokens.create.token
504
505     assert_difference "ActionMailer::Base.deliveries.size", 1 do
506       perform_enqueued_jobs do
507         get :confirm_resend, :params => { :display_name => user.display_name }
508       end
509     end
510
511     assert_response :redirect
512     assert_redirected_to login_path
513     assert_match(/sent a new confirmation/, flash[:notice])
514
515     email = ActionMailer::Base.deliveries.last
516
517     assert_equal user.email, email.to.first
518
519     ActionMailer::Base.deliveries.clear
520   end
521
522   def test_confirm_resend_no_token
523     user = create(:user, :pending)
524     assert_no_difference "ActionMailer::Base.deliveries.size" do
525       perform_enqueued_jobs do
526         get :confirm_resend, :params => { :display_name => user.display_name }
527       end
528     end
529
530     assert_response :redirect
531     assert_redirected_to login_path
532     assert_match "User #{user.display_name} not found.", flash[:error]
533   end
534
535   def test_confirm_resend_unknown_user
536     assert_no_difference "ActionMailer::Base.deliveries.size" do
537       perform_enqueued_jobs do
538         get :confirm_resend, :params => { :display_name => "No Such User" }
539       end
540     end
541
542     assert_response :redirect
543     assert_redirected_to login_path
544     assert_match "User No Such User not found.", flash[:error]
545   end
546
547   def test_confirm_email_get
548     user = create(:user)
549     confirm_string = user.tokens.create.token
550
551     get :confirm_email, :params => { :confirm_string => confirm_string }
552     assert_response :success
553     assert_template :confirm_email
554   end
555
556   def test_confirm_email_success
557     user = create(:user, :new_email => "test-new@example.com")
558     stub_gravatar_request(user.new_email)
559     confirm_string = user.tokens.create.token
560
561     post :confirm_email, :params => { :confirm_string => confirm_string }
562     assert_response :redirect
563     assert_redirected_to :action => :account, :display_name => user.display_name
564     assert_match(/Confirmed your change of email address/, flash[:notice])
565   end
566
567   def test_confirm_email_already_confirmed
568     user = create(:user)
569     confirm_string = user.tokens.create.token
570
571     post :confirm_email, :params => { :confirm_string => confirm_string }
572     assert_response :redirect
573     assert_redirected_to :action => :account, :display_name => user.display_name
574     assert_match(/already been confirmed/, flash[:error])
575   end
576
577   def test_confirm_email_bad_token
578     post :confirm_email, :params => { :confirm_string => "XXXXX" }
579     assert_response :success
580     assert_template :confirm_email
581     assert_match(/confirmation code has expired or does not exist/, flash[:error])
582   end
583
584   ##
585   # test if testing for a gravatar works
586   # this happens when the email is actually changed
587   # which is triggered by the confirmation mail
588   def test_gravatar_auto_enable
589     # switch to email that has a gravatar
590     user = create(:user, :new_email => "test-new@example.com")
591     stub_gravatar_request(user.new_email, 200)
592     confirm_string = user.tokens.create.token
593     # precondition gravatar should be turned off
594     assert_not user.image_use_gravatar
595     post :confirm_email, :params => { :confirm_string => confirm_string }
596     assert_response :redirect
597     assert_redirected_to :action => :account, :display_name => user.display_name
598     assert_match(/Confirmed your change of email address/, flash[:notice])
599     # gravatar use should now be enabled
600     assert User.find(user.id).image_use_gravatar
601   end
602
603   def test_gravatar_auto_disable
604     # switch to email without a gravatar
605     user = create(:user, :new_email => "test-new@example.com", :image_use_gravatar => true)
606     stub_gravatar_request(user.new_email, 404)
607     confirm_string = user.tokens.create.token
608     # precondition gravatar should be turned on
609     assert user.image_use_gravatar
610     post :confirm_email, :params => { :confirm_string => confirm_string }
611     assert_response :redirect
612     assert_redirected_to :action => :account, :display_name => user.display_name
613     assert_match(/Confirmed your change of email address/, flash[:notice])
614     # gravatar use should now be disabled
615     assert_not User.find(user.id).image_use_gravatar
616   end
617
618   def test_terms_new_user
619     get :terms, :session => { :new_user => User.new }
620     assert_response :success
621     assert_template :terms
622   end
623
624   def test_terms_agreed
625     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
626
627     session[:user] = user.id
628
629     get :terms
630     assert_response :redirect
631     assert_redirected_to :action => :account, :display_name => user.display_name
632   end
633
634   def test_terms_not_seen_without_referer
635     user = create(:user, :terms_seen => false, :terms_agreed => nil)
636
637     session[:user] = user.id
638
639     get :terms
640     assert_response :success
641     assert_template :terms
642
643     post :save, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
644     assert_response :redirect
645     assert_redirected_to :action => :account, :display_name => user.display_name
646     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
647
648     user.reload
649
650     assert_equal true, user.consider_pd
651     assert_not_nil user.terms_agreed
652     assert_equal true, user.terms_seen
653   end
654
655   def test_terms_not_seen_with_referer
656     user = create(:user, :terms_seen => false, :terms_agreed => nil)
657
658     session[:user] = user.id
659
660     get :terms, :params => { :referer => "/test" }
661     assert_response :success
662     assert_template :terms
663
664     post :save, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
665     assert_response :redirect
666     assert_redirected_to "/test"
667     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
668
669     user.reload
670
671     assert_equal true, user.consider_pd
672     assert_not_nil user.terms_agreed
673     assert_equal true, user.terms_seen
674   end
675
676   # Check that if you haven't seen the terms, and make a request that requires authentication,
677   # that your request is redirected to view the terms
678   def test_terms_not_seen_redirection
679     user = create(:user, :terms_seen => false, :terms_agreed => nil)
680     session[:user] = user.id
681
682     get :account, :params => { :display_name => user.display_name }
683     assert_response :redirect
684     assert_redirected_to :action => :terms, :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
685   end
686
687   def test_go_public
688     user = create(:user, :data_public => false)
689     post :go_public, :session => { :user => user }
690     assert_response :redirect
691     assert_redirected_to :action => :account, :display_name => user.display_name
692     assert_equal true, User.find(user.id).data_public
693   end
694
695   def test_lost_password
696     # Test fetching the lost password page
697     get :lost_password
698     assert_response :success
699     assert_template :lost_password
700     assert_select "div#notice", false
701
702     # Test resetting using the address as recorded for a user that has an
703     # address which is duplicated in a different case by another user
704     user = create(:user)
705     uppercase_user = build(:user, :email => user.email.upcase).tap { |u| u.save(:validate => false) }
706
707     assert_difference "ActionMailer::Base.deliveries.size", 1 do
708       perform_enqueued_jobs do
709         post :lost_password, :params => { :user => { :email => user.email } }
710       end
711     end
712     assert_response :redirect
713     assert_redirected_to :action => :login
714     assert_match(/^Sorry you lost it/, flash[:notice])
715     email = ActionMailer::Base.deliveries.first
716     assert_equal 1, email.to.count
717     assert_equal user.email, email.to.first
718     ActionMailer::Base.deliveries.clear
719
720     # Test resetting using an address that matches a different user
721     # that has the same address in a different case
722     assert_difference "ActionMailer::Base.deliveries.size", 1 do
723       perform_enqueued_jobs do
724         post :lost_password, :params => { :user => { :email => user.email.upcase } }
725       end
726     end
727     assert_response :redirect
728     assert_redirected_to :action => :login
729     assert_match(/^Sorry you lost it/, flash[:notice])
730     email = ActionMailer::Base.deliveries.first
731     assert_equal 1, email.to.count
732     assert_equal uppercase_user.email, email.to.first
733     ActionMailer::Base.deliveries.clear
734
735     # Test resetting using an address that is a case insensitive match
736     # for more than one user but not an exact match for either
737     assert_no_difference "ActionMailer::Base.deliveries.size" do
738       perform_enqueued_jobs do
739         post :lost_password, :params => { :user => { :email => user.email.titlecase } }
740       end
741     end
742     assert_response :success
743     assert_template :lost_password
744     assert_select ".error", /^Could not find that email address/
745
746     # Test resetting using the address as recorded for a user that has an
747     # address which is case insensitively unique
748     third_user = create(:user)
749     assert_difference "ActionMailer::Base.deliveries.size", 1 do
750       perform_enqueued_jobs do
751         post :lost_password, :params => { :user => { :email => third_user.email } }
752       end
753     end
754     assert_response :redirect
755     assert_redirected_to :action => :login
756     assert_match(/^Sorry you lost it/, flash[:notice])
757     email = ActionMailer::Base.deliveries.first
758     assert_equal 1, email.to.count
759     assert_equal third_user.email, email.to.first
760     ActionMailer::Base.deliveries.clear
761
762     # Test resetting using an address that matches a user that has the
763     # same (case insensitively unique) address in a different case
764     assert_difference "ActionMailer::Base.deliveries.size", 1 do
765       perform_enqueued_jobs do
766         post :lost_password, :params => { :user => { :email => third_user.email.upcase } }
767       end
768     end
769     assert_response :redirect
770     assert_redirected_to :action => :login
771     assert_match(/^Sorry you lost it/, flash[:notice])
772     email = ActionMailer::Base.deliveries.first
773     assert_equal 1, email.to.count
774     assert_equal third_user.email, email.to.first
775     ActionMailer::Base.deliveries.clear
776   end
777
778   def test_reset_password
779     user = create(:user, :pending)
780     # Test a request with no token
781     get :reset_password
782     assert_response :bad_request
783
784     # Test a request with a bogus token
785     get :reset_password, :params => { :token => "made_up_token" }
786     assert_response :redirect
787     assert_redirected_to :action => :lost_password
788
789     # Create a valid token for a user
790     token = user.tokens.create
791
792     # Test a request with a valid token
793     get :reset_password, :params => { :token => token.token }
794     assert_response :success
795     assert_template :reset_password
796
797     # Test that errors are reported for erroneous submissions
798     post :reset_password, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "different_password" } }
799     assert_response :success
800     assert_template :reset_password
801     assert_select "div#errorExplanation"
802
803     # Test setting a new password
804     post :reset_password, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "new_password" } }
805     assert_response :redirect
806     assert_redirected_to root_path
807     assert_equal user.id, session[:user]
808     user.reload
809     assert_equal "active", user.status
810     assert_equal true, user.email_valid
811     assert_equal user, User.authenticate(:username => user.email, :password => "new_password")
812   end
813
814   def test_account
815     # Get a user to work with - note that this user deliberately
816     # conflicts with uppercase_user in the email and display name
817     # fields to test that we can change other fields without any
818     # validation errors being reported
819     user = create(:user, :languages => [])
820     _uppercase_user = build(:user, :email => user.email.upcase, :display_name => user.display_name.upcase).tap { |u| u.save(:validate => false) }
821
822     # Make sure that you are redirected to the login page when
823     # you are not logged in
824     get :account, :params => { :display_name => user.display_name }
825     assert_response :redirect
826     assert_redirected_to :action => "login", :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
827
828     # Make sure that you are blocked when not logged in as the right user
829     get :account, :params => { :display_name => user.display_name }, :session => { :user => create(:user) }
830     assert_response :forbidden
831
832     # Make sure we get the page when we are logged in as the right user
833     get :account, :params => { :display_name => user.display_name }, :session => { :user => user }
834     assert_response :success
835     assert_template :account
836     assert_select "form#accountForm" do |form|
837       assert_equal "post", form.attr("method").to_s
838       assert_select "input[name='_method']", false
839       assert_equal "/user/#{ERB::Util.u(user.display_name)}/account", form.attr("action").to_s
840     end
841
842     # Updating the description should work
843     user.description = "new description"
844     user.preferred_editor = "default"
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 "div#errorExplanation", false
849     assert_select ".notice", /^User information updated successfully/
850     assert_select "form#accountForm > fieldset > div.form-row > div#user_description_container > div#user_description_content > textarea#user_description", user.description
851
852     # Changing to a invalid editor should fail
853     user.preferred_editor = "unknown"
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 ".notice", false
858     assert_select "div#errorExplanation"
859     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected]", false
860
861     # Changing to a valid editor should work
862     user.preferred_editor = "potlatch2"
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][value=?]", "potlatch2"
869
870     # Changing to the default editor should work
871     user.preferred_editor = "default"
872     post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :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 > select#user_preferred_editor > option[selected]", false
878
879     # Changing to an uploaded image should work
880     image = Rack::Test::UploadedFile.new("test/gpx/fixtures/a.gif", "image/gif")
881     post :account, :params => { :display_name => user.display_name, :avatar_action => "new", :user => user.attributes.merge(:avatar => image) }, :session => { :user => user }
882     assert_response :success
883     assert_template :account
884     assert_select "div#errorExplanation", false
885     assert_select ".notice", /^User information updated successfully/
886     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked][value=?]", "keep"
887
888     # Changing to a gravatar image should work
889     post :account, :params => { :display_name => user.display_name, :avatar_action => "gravatar", :user => user.attributes }, :session => { :user => user }
890     assert_response :success
891     assert_template :account
892     assert_select "div#errorExplanation", false
893     assert_select ".notice", /^User information updated successfully/
894     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked][value=?]", "gravatar"
895
896     # Removing the image should work
897     post :account, :params => { :display_name => user.display_name, :avatar_action => "delete", :user => user.attributes }, :session => { :user => user }
898     assert_response :success
899     assert_template :account
900     assert_select "div#errorExplanation", false
901     assert_select ".notice", /^User information updated successfully/
902     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=avatar_action][checked]", false
903
904     # Adding external authentication should redirect to the auth provider
905     post :account, :params => { :display_name => user.display_name, :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }, :session => { :user => user }
906     assert_response :redirect
907     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")
908
909     # Changing name to one that exists should fail
910     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name)
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 exists should fail, regardless of case
919     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name.upcase)
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 ".notice", false
924     assert_select "div#errorExplanation"
925     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
926
927     # Changing name to one that doesn't exist should work
928     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
929     post :account, :params => { :display_name => user.display_name, :user => new_attributes }, :session => { :user => user }
930     assert_response :success
931     assert_template :account
932     assert_select "div#errorExplanation", false
933     assert_select ".notice", /^User information updated successfully/
934     assert_select "form#accountForm > fieldset > div.form-row > input#user_display_name[value=?]", "new tester"
935
936     # Record the change of name
937     user.display_name = "new tester"
938
939     # Changing email to one that exists should fail
940     user.new_email = create(:user).email
941     assert_no_difference "ActionMailer::Base.deliveries.size" do
942       perform_enqueued_jobs do
943         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
944       end
945     end
946     assert_response :success
947     assert_template :account
948     assert_select ".notice", false
949     assert_select "div#errorExplanation"
950     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
951
952     # Changing email to one that exists should fail, regardless of case
953     user.new_email = create(:user).email.upcase
954     assert_no_difference "ActionMailer::Base.deliveries.size" do
955       perform_enqueued_jobs do
956         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
957       end
958     end
959     assert_response :success
960     assert_template :account
961     assert_select ".notice", false
962     assert_select "div#errorExplanation"
963     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
964
965     # Changing email to one that doesn't exist should work
966     user.new_email = "new_tester@example.com"
967     assert_difference "ActionMailer::Base.deliveries.size", 1 do
968       perform_enqueued_jobs do
969         post :account, :params => { :display_name => user.display_name, :user => user.attributes }, :session => { :user => user }
970       end
971     end
972     assert_response :success
973     assert_template :account
974     assert_select "div#errorExplanation", false
975     assert_select ".notice", /^User information updated successfully/
976     assert_select "form#accountForm > fieldset > div.form-row > input#user_new_email[value=?]", user.new_email
977     email = ActionMailer::Base.deliveries.first
978     assert_equal 1, email.to.count
979     assert_equal user.new_email, email.to.first
980     ActionMailer::Base.deliveries.clear
981   end
982
983   # Check that the user account page will display and contains some relevant
984   # information for the user
985   def test_show
986     # Test a non-existent user
987     get :show, :params => { :display_name => "unknown" }
988     assert_response :not_found
989
990     # Test a normal user
991     user = create(:user, :home_lon => 1.1, :home_lat => 1.1)
992     friend_user = create(:user, :home_lon => 1.2, :home_lat => 1.2)
993     create(:friendship, :befriender => user, :befriendee => friend_user)
994     create(:changeset, :user => friend_user)
995
996     get :show, :params => { :display_name => user.display_name }
997     assert_response :success
998     assert_select "div#userinformation" do
999       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1000       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
1001       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1002       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1003       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
1004       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1005       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1006       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
1007     end
1008
1009     # Friends shouldn't be visible as we're not logged in
1010     assert_select "div#friends-container", :count => 0
1011
1012     # Test a user who has been blocked
1013     blocked_user = create(:user)
1014     create(:user_block, :user => blocked_user)
1015     get :show, :params => { :display_name => blocked_user.display_name }
1016     assert_response :success
1017     assert_select "div#userinformation" do
1018       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
1019       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
1020       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
1021       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
1022       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
1023       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
1024       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
1025       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
1026     end
1027
1028     # Test a moderator who has applied blocks
1029     moderator_user = create(:moderator_user)
1030     create(:user_block, :creator => moderator_user)
1031     get :show, :params => { :display_name => moderator_user.display_name }
1032     assert_response :success
1033     assert_select "div#userinformation" do
1034       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
1035       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
1036       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
1037       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
1038       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
1039       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
1040       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
1041       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
1042     end
1043
1044     # Login as a normal user
1045     session[:user] = user.id
1046
1047     # Test the normal user
1048     get :show, :params => { :display_name => user.display_name }
1049     assert_response :success
1050     assert_select "div#userinformation" do
1051       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1052       assert_select "a[href='/traces/mine']", 1
1053       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1054       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1055       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 1
1056       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1057       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1058       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
1059     end
1060
1061     # Friends should be visible as we're now logged in
1062     assert_select "div#friends-container" do
1063       assert_select "div.contact-activity", :count => 1
1064     end
1065
1066     # Login as a moderator
1067     session[:user] = create(:moderator_user).id
1068
1069     # Test the normal user
1070     get :show, :params => { :display_name => user.display_name }
1071     assert_response :success
1072     assert_select "div#userinformation" do
1073       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1074       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
1075       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1076       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1077       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
1078       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1079       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1080       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
1081     end
1082   end
1083
1084   # Test whether information about contributor terms is shown for users who haven't agreed
1085   def test_terms_not_agreed
1086     agreed_user = create(:user, :terms_agreed => 3.days.ago)
1087     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
1088     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
1089
1090     get :show, :params => { :display_name => agreed_user.display_name }
1091     assert_response :success
1092     assert_select "div#userinformation" do
1093       assert_select "p", :count => 0, :text => /Contributor terms/
1094     end
1095
1096     get :show, :params => { :display_name => seen_user.display_name }
1097     assert_response :success
1098     # put @response.body
1099     assert_select "div#userinformation" do
1100       assert_select "p", :count => 1, :text => /Contributor terms/
1101       assert_select "p", /Declined/
1102     end
1103
1104     get :show, :params => { :display_name => not_seen_user.display_name }
1105     assert_response :success
1106     assert_select "div#userinformation" do
1107       assert_select "p", :count => 1, :text => /Contributor terms/
1108       assert_select "p", /Undecided/
1109     end
1110   end
1111
1112   def test_make_friend
1113     # Get users to work with
1114     user = create(:user)
1115     friend = create(:user)
1116
1117     # Check that the users aren't already friends
1118     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1119
1120     # When not logged in a GET should ask us to login
1121     get :make_friend, :params => { :display_name => friend.display_name }
1122     assert_redirected_to :action => "login", :referer => make_friend_path(:display_name => friend.display_name)
1123
1124     # When not logged in a POST should error
1125     post :make_friend, :params => { :display_name => friend.display_name }
1126     assert_response :forbidden
1127     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1128
1129     # When logged in a GET should get a confirmation page
1130     get :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1131     assert_response :success
1132     assert_template :make_friend
1133     assert_select "form" do
1134       assert_select "input[type='hidden'][name='referer']", 0
1135       assert_select "input[type='submit']", 1
1136     end
1137     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1138
1139     # When logged in a POST should add the friendship
1140     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1141       perform_enqueued_jobs do
1142         post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1143       end
1144     end
1145     assert_redirected_to user_path(friend)
1146     assert_match(/is now your friend/, flash[:notice])
1147     assert Friendship.where(:befriender => user, :befriendee => friend).first
1148     email = ActionMailer::Base.deliveries.first
1149     assert_equal 1, email.to.count
1150     assert_equal friend.email, email.to.first
1151     ActionMailer::Base.deliveries.clear
1152
1153     # A second POST should report that the friendship already exists
1154     assert_no_difference "ActionMailer::Base.deliveries.size" do
1155       perform_enqueued_jobs do
1156         post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1157       end
1158     end
1159     assert_redirected_to user_path(friend)
1160     assert_match(/You are already friends with/, flash[:warning])
1161     assert Friendship.where(:befriender => user, :befriendee => friend).first
1162   end
1163
1164   def test_make_friend_with_referer
1165     # Get users to work with
1166     user = create(:user)
1167     friend = create(:user)
1168
1169     # Check that the users aren't already friends
1170     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1171
1172     # The GET should preserve any referer
1173     get :make_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1174     assert_response :success
1175     assert_template :make_friend
1176     assert_select "form" do
1177       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1178       assert_select "input[type='submit']", 1
1179     end
1180     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1181
1182     # When logged in a POST should add the friendship and refer us
1183     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1184       perform_enqueued_jobs do
1185         post :make_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1186       end
1187     end
1188     assert_redirected_to "/test"
1189     assert_match(/is now your friend/, flash[:notice])
1190     assert Friendship.where(:befriender => user, :befriendee => friend).first
1191     email = ActionMailer::Base.deliveries.first
1192     assert_equal 1, email.to.count
1193     assert_equal friend.email, email.to.first
1194     ActionMailer::Base.deliveries.clear
1195   end
1196
1197   def test_make_friend_unkown_user
1198     # Should error when a bogus user is specified
1199     get :make_friend, :params => { :display_name => "No Such User" }, :session => { :user => create(:user) }
1200     assert_response :not_found
1201     assert_template :no_such_user
1202   end
1203
1204   def test_remove_friend
1205     # Get users to work with
1206     user = create(:user)
1207     friend = create(:user)
1208     create(:friendship, :befriender => user, :befriendee => friend)
1209
1210     # Check that the users are friends
1211     assert Friendship.where(:befriender => user, :befriendee => friend).first
1212
1213     # When not logged in a GET should ask us to login
1214     get :remove_friend, :params => { :display_name => friend.display_name }
1215     assert_redirected_to :action => "login", :referer => remove_friend_path(:display_name => friend.display_name)
1216
1217     # When not logged in a POST should error
1218     post :remove_friend, :params => { :display_name => friend.display_name }
1219     assert_response :forbidden
1220     assert Friendship.where(:befriender => user, :befriendee => friend).first
1221
1222     # When logged in a GET should get a confirmation page
1223     get :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1224     assert_response :success
1225     assert_template :remove_friend
1226     assert_select "form" do
1227       assert_select "input[type='hidden'][name='referer']", 0
1228       assert_select "input[type='submit']", 1
1229     end
1230     assert Friendship.where(:befriender => user, :befriendee => friend).first
1231
1232     # When logged in a POST should remove the friendship
1233     post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1234     assert_redirected_to user_path(friend)
1235     assert_match(/was removed from your friends/, flash[:notice])
1236     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1237
1238     # A second POST should report that the friendship does not exist
1239     post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
1240     assert_redirected_to user_path(friend)
1241     assert_match(/is not one of your friends/, flash[:error])
1242     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1243   end
1244
1245   def test_remove_friend_with_referer
1246     # Get users to work with
1247     user = create(:user)
1248     friend = create(:user)
1249     create(:friendship, :befriender => user, :befriendee => friend)
1250
1251     # Check that the users are friends
1252     assert Friendship.where(:befriender => user, :befriendee => friend).first
1253
1254     # The GET should preserve any referer
1255     get :remove_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1256     assert_response :success
1257     assert_template :remove_friend
1258     assert_select "form" do
1259       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1260       assert_select "input[type='submit']", 1
1261     end
1262     assert Friendship.where(:befriender => user, :befriendee => friend).first
1263
1264     # When logged in a POST should remove the friendship and refer
1265     post :remove_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
1266     assert_redirected_to "/test"
1267     assert_match(/was removed from your friends/, flash[:notice])
1268     assert_nil Friendship.where(:befriender => user, :befriendee => friend).first
1269   end
1270
1271   def test_remove_friend_unkown_user
1272     # Should error when a bogus user is specified
1273     get :remove_friend, :params => { :display_name => "No Such User" }, :session => { :user => create(:user) }
1274     assert_response :not_found
1275     assert_template :no_such_user
1276   end
1277
1278   def test_set_status
1279     user = create(:user)
1280
1281     # Try without logging in
1282     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }
1283     assert_response :redirect
1284     assert_redirected_to :action => :login, :referer => set_status_user_path(:status => "suspended")
1285
1286     # Now try as a normal user
1287     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => user }
1288     assert_response :redirect
1289     assert_redirected_to :controller => :errors, :action => :forbidden
1290
1291     # Finally try as an administrator
1292     get :set_status, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => create(:administrator_user) }
1293     assert_response :redirect
1294     assert_redirected_to :action => :show, :display_name => user.display_name
1295     assert_equal "suspended", User.find(user.id).status
1296   end
1297
1298   def test_delete
1299     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
1300
1301     # Try without logging in
1302     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }
1303     assert_response :redirect
1304     assert_redirected_to :action => :login, :referer => delete_user_path(:status => "suspended")
1305
1306     # Now try as a normal user
1307     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => user }
1308     assert_response :redirect
1309     assert_redirected_to :controller => :errors, :action => :forbidden
1310
1311     # Finally try as an administrator
1312     get :delete, :params => { :display_name => user.display_name, :status => "suspended" }, :session => { :user => create(:administrator_user) }
1313     assert_response :redirect
1314     assert_redirected_to :action => :show, :display_name => user.display_name
1315
1316     # Check that the user was deleted properly
1317     user.reload
1318     assert_equal "user_#{user.id}", user.display_name
1319     assert_equal "", user.description
1320     assert_nil user.home_lat
1321     assert_nil user.home_lon
1322     assert_equal false, user.avatar.attached?
1323     assert_equal false, user.email_valid
1324     assert_nil user.new_email
1325     assert_nil user.auth_provider
1326     assert_nil user.auth_uid
1327     assert_equal "deleted", user.status
1328   end
1329
1330   def test_index_get
1331     user = create(:user)
1332     moderator_user = create(:moderator_user)
1333     administrator_user = create(:administrator_user)
1334     _suspended_user = create(:user, :suspended)
1335     _ip_user = create(:user, :creation_ip => "1.2.3.4")
1336
1337     # There are now 7 users - the five above, plus two extra "granters" for the
1338     # moderator_user and administrator_user
1339     assert_equal 7, User.count
1340
1341     # Shouldn't work when not logged in
1342     get :index
1343     assert_response :redirect
1344     assert_redirected_to :action => :login, :referer => users_path
1345
1346     session[:user] = user.id
1347
1348     # Shouldn't work when logged in as a normal user
1349     get :index
1350     assert_response :redirect
1351     assert_redirected_to :controller => :errors, :action => :forbidden
1352
1353     session[:user] = moderator_user.id
1354
1355     # Shouldn't work when logged in as a moderator
1356     get :index
1357     assert_response :redirect
1358     assert_redirected_to :controller => :errors, :action => :forbidden
1359
1360     session[:user] = administrator_user.id
1361
1362     # Note there is a header row, so all row counts are users + 1
1363     # Should work when logged in as an administrator
1364     get :index
1365     assert_response :success
1366     assert_template :index
1367     assert_select "table#user_list tr", :count => 7 + 1
1368
1369     # Should be able to limit by status
1370     get :index, :params => { :status => "suspended" }
1371     assert_response :success
1372     assert_template :index
1373     assert_select "table#user_list tr", :count => 1 + 1
1374
1375     # Should be able to limit by IP address
1376     get :index, :params => { :ip => "1.2.3.4" }
1377     assert_response :success
1378     assert_template :index
1379     assert_select "table#user_list tr", :count => 1 + 1
1380   end
1381
1382   def test_index_get_paginated
1383     1.upto(100).each do |n|
1384       User.create(:display_name => "extra_#{n}",
1385                   :email => "extra#{n}@example.com",
1386                   :pass_crypt => "extraextra")
1387     end
1388
1389     session[:user] = create(:administrator_user).id
1390
1391     # 100 examples, an administrator, and a granter for the admin.
1392     assert_equal 102, User.count
1393
1394     get :index
1395     assert_response :success
1396     assert_template :index
1397     assert_select "table#user_list tr", :count => 51
1398
1399     get :index, :params => { :page => 2 }
1400     assert_response :success
1401     assert_template :index
1402     assert_select "table#user_list tr", :count => 51
1403
1404     get :index, :params => { :page => 3 }
1405     assert_response :success
1406     assert_template :index
1407     assert_select "table#user_list tr", :count => 3
1408   end
1409
1410   def test_index_post_confirm
1411     inactive_user = create(:user, :pending)
1412     suspended_user = create(:user, :suspended)
1413
1414     # Shouldn't work when not logged in
1415     assert_no_difference "User.active.count" do
1416       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1417     end
1418     assert_response :forbidden
1419
1420     assert_equal "pending", inactive_user.reload.status
1421     assert_equal "suspended", suspended_user.reload.status
1422
1423     session[:user] = create(:user).id
1424
1425     # Shouldn't work when logged in as a normal user
1426     assert_no_difference "User.active.count" do
1427       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1428     end
1429     assert_response :redirect
1430     assert_redirected_to :controller => :errors, :action => :forbidden
1431     assert_equal "pending", inactive_user.reload.status
1432     assert_equal "suspended", suspended_user.reload.status
1433
1434     session[:user] = create(:moderator_user).id
1435
1436     # Shouldn't work when logged in as a moderator
1437     assert_no_difference "User.active.count" do
1438       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1439     end
1440     assert_response :redirect
1441     assert_redirected_to :controller => :errors, :action => :forbidden
1442     assert_equal "pending", inactive_user.reload.status
1443     assert_equal "suspended", suspended_user.reload.status
1444
1445     session[:user] = create(:administrator_user).id
1446
1447     # Should work when logged in as an administrator
1448     assert_difference "User.active.count", 2 do
1449       post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1450     end
1451     assert_response :redirect
1452     assert_redirected_to :action => :index
1453     assert_equal "confirmed", inactive_user.reload.status
1454     assert_equal "confirmed", suspended_user.reload.status
1455   end
1456
1457   def test_index_post_hide
1458     normal_user = create(:user)
1459     confirmed_user = create(:user, :confirmed)
1460
1461     # Shouldn't work when not logged in
1462     assert_no_difference "User.active.count" do
1463       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1464     end
1465     assert_response :forbidden
1466
1467     assert_equal "active", normal_user.reload.status
1468     assert_equal "confirmed", confirmed_user.reload.status
1469
1470     session[:user] = create(:user).id
1471
1472     # Shouldn't work when logged in as a normal user
1473     assert_no_difference "User.active.count" do
1474       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1475     end
1476     assert_response :redirect
1477     assert_redirected_to :controller => :errors, :action => :forbidden
1478     assert_equal "active", normal_user.reload.status
1479     assert_equal "confirmed", confirmed_user.reload.status
1480
1481     session[:user] = create(:moderator_user).id
1482
1483     # Shouldn't work when logged in as a moderator
1484     assert_no_difference "User.active.count" do
1485       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1486     end
1487     assert_response :redirect
1488     assert_redirected_to :controller => :errors, :action => :forbidden
1489     assert_equal "active", normal_user.reload.status
1490     assert_equal "confirmed", confirmed_user.reload.status
1491
1492     session[:user] = create(:administrator_user).id
1493
1494     # Should work when logged in as an administrator
1495     assert_difference "User.active.count", -2 do
1496       post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1497     end
1498     assert_response :redirect
1499     assert_redirected_to :action => :index
1500     assert_equal "deleted", normal_user.reload.status
1501     assert_equal "deleted", confirmed_user.reload.status
1502   end
1503 end