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