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