]> git.openstreetmap.org Git - rails.git/blob - test/controllers/api/users_controller_test.rb
d0d1e0dcf1e2a31ce9893bdfcd6c7b153d7d2be3
[rails.git] / test / controllers / api / users_controller_test.rb
1 require "test_helper"
2
3 module Api
4   class UsersControllerTest < ActionDispatch::IntegrationTest
5     ##
6     # test all routes which lead to this controller
7     def test_routes
8       assert_routing(
9         { :path => "/api/0.6/user/1", :method => :get },
10         { :controller => "api/users", :action => "show", :id => "1" }
11       )
12       assert_routing(
13         { :path => "/api/0.6/user/1.json", :method => :get },
14         { :controller => "api/users", :action => "show", :id => "1", :format => "json" }
15       )
16       assert_routing(
17         { :path => "/api/0.6/user/details", :method => :get },
18         { :controller => "api/users", :action => "details" }
19       )
20       assert_routing(
21         { :path => "/api/0.6/user/details.json", :method => :get },
22         { :controller => "api/users", :action => "details", :format => "json" }
23       )
24       assert_routing(
25         { :path => "/api/0.6/user/gpx_files", :method => :get },
26         { :controller => "api/users", :action => "gpx_files" }
27       )
28       assert_routing(
29         { :path => "/api/0.6/users", :method => :get },
30         { :controller => "api/users", :action => "index" }
31       )
32       assert_routing(
33         { :path => "/api/0.6/users.json", :method => :get },
34         { :controller => "api/users", :action => "index", :format => "json" }
35       )
36     end
37
38     def test_show
39       user = create(:user,
40                     :description => "test",
41                     :terms_agreed => Date.yesterday,
42                     :home_lat => 12.1, :home_lon => 23.4,
43                     :languages => ["en"])
44
45       # check that a visible user is returned properly
46       get api_user_path(:id => user.id)
47       assert_response :success
48       assert_equal "application/xml", response.media_type
49
50       # check the data that is returned
51       check_xml_details(user, false)
52
53       # check that a suspended user is not returned
54       get api_user_path(:id => create(:user, :suspended).id)
55       assert_response :gone
56
57       # check that a deleted user is not returned
58       get api_user_path(:id => create(:user, :deleted).id)
59       assert_response :gone
60
61       # check that a non-existent user is not returned
62       get api_user_path(:id => 0)
63       assert_response :not_found
64
65       # check that a visible user is returned properly in json
66       get api_user_path(:id => user.id, :format => "json")
67       assert_response :success
68       assert_equal "application/json", response.media_type
69
70       # parse the response
71       js = ActiveSupport::JSON.decode(@response.body)
72       assert_not_nil js
73
74       # check the data that is returned
75       check_json_details(js, user, false)
76     end
77
78     def test_show_oauth1
79       user = create(:user,
80                     :home_lat => 12.1, :home_lon => 23.4,
81                     :languages => ["en"])
82       good_token = create(:access_token,
83                           :user => user,
84                           :allow_read_prefs => true)
85       bad_token = create(:access_token,
86                          :user => user)
87       other_user = create(:user,
88                           :home_lat => 12.1, :home_lon => 23.4,
89                           :languages => ["en"])
90
91       # check that we can fetch our own details as XML with read_prefs
92       signed_get api_user_path(:id => user.id), :oauth => { :token => good_token }
93       assert_response :success
94       assert_equal "application/xml", response.media_type
95
96       # check the data that is returned
97       check_xml_details(user, true)
98
99       # check that we can fetch a different user's details as XML with read_prefs
100       signed_get api_user_path(:id => other_user.id), :oauth => { :token => good_token }
101       assert_response :success
102       assert_equal "application/xml", response.media_type
103
104       # check the data that is returned
105       check_xml_details(other_user, false)
106
107       # check that we can fetch our own details as XML without read_prefs
108       signed_get api_user_path(:id => user.id), :oauth => { :token => bad_token }
109       assert_response :success
110       assert_equal "application/xml", response.media_type
111
112       # check the data that is returned
113       check_xml_details(user, false)
114
115       # check that we can fetch our own details as JSON with read_prefs
116       signed_get api_user_path(:id => user.id, :format => "json"), :oauth => { :token => good_token }
117       assert_response :success
118       assert_equal "application/json", response.media_type
119
120       # parse the response
121       js = ActiveSupport::JSON.decode(@response.body)
122       assert_not_nil js
123
124       # check the data that is returned
125       check_json_details(js, user, true)
126
127       # check that we can fetch a different user's details as JSON with read_prefs
128       signed_get api_user_path(:id => other_user.id, :format => "json"), :oauth => { :token => good_token }
129       assert_response :success
130       assert_equal "application/json", response.media_type
131
132       # parse the response
133       js = ActiveSupport::JSON.decode(@response.body)
134       assert_not_nil js
135
136       # check the data that is returned
137       check_json_details(js, other_user, false)
138
139       # check that we can fetch our own details as JSON without read_prefs
140       signed_get api_user_path(:id => other_user.id, :format => "json"), :oauth => { :token => bad_token }
141       assert_response :success
142       assert_equal "application/json", response.media_type
143
144       # parse the response
145       js = ActiveSupport::JSON.decode(@response.body)
146       assert_not_nil js
147
148       # check the data that is returned
149       check_json_details(js, other_user, false)
150     end
151
152     def test_show_oauth2
153       user = create(:user,
154                     :home_lat => 12.1, :home_lon => 23.4,
155                     :languages => ["en"])
156       good_token = create(:oauth_access_token,
157                           :resource_owner_id => user.id,
158                           :scopes => %w[read_prefs])
159       bad_token = create(:oauth_access_token,
160                          :resource_owner_id => user.id,
161                          :scopes => %w[])
162       other_user = create(:user,
163                           :home_lat => 12.1, :home_lon => 23.4,
164                           :languages => ["en"])
165
166       # check that we can fetch our own details as XML with read_prefs
167       get api_user_path(:id => user.id), :headers => bearer_authorization_header(good_token.token)
168       assert_response :success
169       assert_equal "application/xml", response.media_type
170
171       # check the data that is returned
172       check_xml_details(user, true)
173
174       # check that we can fetch a different user's details as XML with read_prefs
175       get api_user_path(:id => other_user.id), :headers => bearer_authorization_header(good_token.token)
176       assert_response :success
177       assert_equal "application/xml", response.media_type
178
179       # check the data that is returned
180       check_xml_details(other_user, false)
181
182       # check that we can fetch our own details as XML without read_prefs
183       get api_user_path(:id => user.id), :headers => bearer_authorization_header(bad_token.token)
184       assert_response :success
185       assert_equal "application/xml", response.media_type
186
187       # check the data that is returned
188       check_xml_details(user, false)
189
190       # check that we can fetch our own details as JSON with read_prefs
191       get api_user_path(:id => user.id, :format => "json"), :headers => bearer_authorization_header(good_token.token)
192       assert_response :success
193       assert_equal "application/json", response.media_type
194
195       # parse the response
196       js = ActiveSupport::JSON.decode(@response.body)
197       assert_not_nil js
198
199       # check the data that is returned
200       check_json_details(js, user, true)
201
202       # check that we can fetch a different user's details as JSON with read_prefs
203       get api_user_path(:id => other_user.id, :format => "json"), :headers => bearer_authorization_header(good_token.token)
204       assert_response :success
205       assert_equal "application/json", response.media_type
206
207       # parse the response
208       js = ActiveSupport::JSON.decode(@response.body)
209       assert_not_nil js
210
211       # check the data that is returned
212       check_json_details(js, other_user, false)
213
214       # check that we can fetch our own details as JSON without read_prefs
215       get api_user_path(:id => user.id, :format => "json"), :headers => bearer_authorization_header(bad_token.token)
216       assert_response :success
217       assert_equal "application/json", response.media_type
218
219       # parse the response
220       js = ActiveSupport::JSON.decode(@response.body)
221       assert_not_nil js
222
223       # check the data that is returned
224       check_json_details(js, user, false)
225     end
226
227     def test_details
228       user = create(:user,
229                     :description => "test",
230                     :terms_agreed => Date.yesterday,
231                     :home_lat => 12.1, :home_lon => 23.4,
232                     :languages => ["en"])
233       create(:message, :read, :recipient => user)
234       create(:message, :sender => user)
235
236       # check that nothing is returned when not logged in
237       get user_details_path
238       assert_response :unauthorized
239
240       # check that we get a response when logged in
241       auth_header = basic_authorization_header user.email, "test"
242       get user_details_path, :headers => auth_header
243       assert_response :success
244       assert_equal "application/xml", response.media_type
245
246       # check the data that is returned
247       check_xml_details(user, true)
248
249       # check that data is returned properly in json
250       auth_header = basic_authorization_header user.email, "test"
251       get user_details_path(:format => "json"), :headers => auth_header
252       assert_response :success
253       assert_equal "application/json", response.media_type
254
255       # parse the response
256       js = ActiveSupport::JSON.decode(@response.body)
257       assert_not_nil js
258
259       # check the data that is returned
260       check_json_details(js, user, true)
261     end
262
263     def test_details_oauth1
264       user = create(:user,
265                     :home_lat => 12.1, :home_lon => 23.4,
266                     :languages => ["en"])
267       good_token = create(:access_token,
268                           :user => user,
269                           :allow_read_prefs => true)
270       bad_token = create(:access_token,
271                          :user => user)
272
273       # check that we can't fetch details as XML without read_prefs
274       signed_get user_details_path, :oauth => { :token => bad_token }
275       assert_response :forbidden
276
277       # check that we can fetch details as XML
278       signed_get user_details_path, :oauth => { :token => good_token }
279       assert_response :success
280       assert_equal "application/xml", response.media_type
281
282       # check the data that is returned
283       check_xml_details(user, true)
284
285       # check that we can't fetch details as JSON without read_prefs
286       signed_get user_details_path(:format => "json"), :oauth => { :token => bad_token }
287       assert_response :forbidden
288
289       # check that we can fetch details as JSON
290       signed_get user_details_path(:format => "json"), :oauth => { :token => good_token }
291       assert_response :success
292       assert_equal "application/json", response.media_type
293
294       # parse the response
295       js = ActiveSupport::JSON.decode(@response.body)
296       assert_not_nil js
297
298       # check the data that is returned
299       check_json_details(js, user, true)
300     end
301
302     def test_details_oauth2
303       user = create(:user,
304                     :home_lat => 12.1, :home_lon => 23.4,
305                     :languages => ["en"])
306       good_token = create(:oauth_access_token,
307                           :resource_owner_id => user.id,
308                           :scopes => %w[read_prefs])
309       bad_token = create(:oauth_access_token,
310                          :resource_owner_id => user.id)
311
312       # check that we can't fetch details as XML without read_prefs
313       get user_details_path, :headers => bearer_authorization_header(bad_token.token)
314       assert_response :forbidden
315
316       # check that we can fetch details as XML
317       get user_details_path, :headers => bearer_authorization_header(good_token.token)
318       assert_response :success
319       assert_equal "application/xml", response.media_type
320
321       # check the data that is returned
322       check_xml_details(user, true)
323
324       # check that we can't fetch details as JSON without read_prefs
325       get user_details_path(:format => "json"), :headers => bearer_authorization_header(bad_token.token)
326       assert_response :forbidden
327
328       # check that we can fetch details as JSON
329       get user_details_path(:format => "json"), :headers => bearer_authorization_header(good_token.token)
330       assert_response :success
331       assert_equal "application/json", response.media_type
332
333       # parse the response
334       js = ActiveSupport::JSON.decode(@response.body)
335       assert_not_nil js
336
337       # check the data that is returned
338       check_json_details(js, user, true)
339     end
340
341     def test_index
342       user1 = create(:user, :description => "test1", :terms_agreed => Date.yesterday)
343       user2 = create(:user, :description => "test2", :terms_agreed => Date.yesterday)
344       user3 = create(:user, :description => "test3", :terms_agreed => Date.yesterday)
345
346       get api_users_path, :params => { :users => user1.id }
347       assert_response :success
348       assert_equal "application/xml", response.media_type
349       assert_select "user", :count => 1 do
350         check_xml_details(user1, false)
351         assert_select "user[id='#{user2.id}']", :count => 0
352         assert_select "user[id='#{user3.id}']", :count => 0
353       end
354
355       get api_users_path, :params => { :users => user2.id }
356       assert_response :success
357       assert_equal "application/xml", response.media_type
358       assert_select "user", :count => 1 do
359         assert_select "user[id='#{user1.id}']", :count => 0
360         check_xml_details(user2, false)
361         assert_select "user[id='#{user3.id}']", :count => 0
362       end
363
364       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }
365       assert_response :success
366       assert_equal "application/xml", response.media_type
367       assert_select "user", :count => 2 do
368         check_xml_details(user1, false)
369         assert_select "user[id='#{user2.id}']", :count => 0
370         check_xml_details(user3, false)
371       end
372
373       get api_users_path, :params => { :users => user1.id, :format => "json" }
374       assert_response :success
375       assert_equal "application/json", response.media_type
376       js = ActiveSupport::JSON.decode(@response.body)
377       assert_not_nil js
378       assert_equal 1, js["users"].count
379       check_json_details(js["users"][0], user1, false)
380
381       get api_users_path, :params => { :users => user2.id, :format => "json" }
382       assert_response :success
383       assert_equal "application/json", response.media_type
384       js = ActiveSupport::JSON.decode(@response.body)
385       assert_not_nil js
386       assert_equal 1, js["users"].count
387       check_json_details(js["users"][0], user2, false)
388
389       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }
390       assert_response :success
391       assert_equal "application/json", response.media_type
392       js = ActiveSupport::JSON.decode(@response.body)
393       assert_not_nil js
394       assert_equal 2, js["users"].count
395       check_json_details(js["users"][0], user1, false)
396       check_json_details(js["users"][1], user3, false)
397
398       get api_users_path, :params => { :users => create(:user, :suspended).id }
399       assert_response :not_found
400
401       get api_users_path, :params => { :users => create(:user, :deleted).id }
402       assert_response :not_found
403
404       get api_users_path, :params => { :users => 0 }
405       assert_response :not_found
406     end
407
408     def test_index_oauth1
409       user1 = create(:user, :description => "test1", :terms_agreed => Date.yesterday)
410       user2 = create(:user, :description => "test2", :terms_agreed => Date.yesterday)
411       user3 = create(:user, :description => "test3", :terms_agreed => Date.yesterday)
412       good_token = create(:access_token, :user => user1, :allow_read_prefs => true)
413       bad_token = create(:access_token, :user => user1)
414
415       signed_get api_users_path, :params => { :users => user1.id }, :oauth => { :token => good_token }
416       assert_response :success
417       assert_equal "application/xml", response.media_type
418       assert_select "user", :count => 1 do
419         check_xml_details(user1, true)
420         assert_select "user[id='#{user2.id}']", :count => 0
421         assert_select "user[id='#{user3.id}']", :count => 0
422       end
423
424       signed_get api_users_path, :params => { :users => user2.id }, :oauth => { :token => good_token }
425       assert_response :success
426       assert_equal "application/xml", response.media_type
427       assert_select "user", :count => 1 do
428         assert_select "user[id='#{user1.id}']", :count => 0
429         check_xml_details(user2, false)
430         assert_select "user[id='#{user3.id}']", :count => 0
431       end
432
433       signed_get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :oauth => { :token => good_token }
434       assert_response :success
435       assert_equal "application/xml", response.media_type
436       assert_select "user", :count => 2 do
437         check_xml_details(user1, true)
438         assert_select "user[id='#{user2.id}']", :count => 0
439         check_xml_details(user3, false)
440       end
441
442       signed_get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :oauth => { :token => bad_token }
443       assert_response :success
444       assert_equal "application/xml", response.media_type
445       assert_select "user", :count => 2 do
446         check_xml_details(user1, false)
447         assert_select "user[id='#{user2.id}']", :count => 0
448         check_xml_details(user3, false)
449       end
450
451       signed_get api_users_path, :params => { :users => user1.id, :format => "json" }, :oauth => { :token => good_token }
452       assert_response :success
453       assert_equal "application/json", response.media_type
454       js = ActiveSupport::JSON.decode(@response.body)
455       assert_not_nil js
456       assert_equal 1, js["users"].count
457       check_json_details(js["users"][0], user1, true)
458
459       signed_get api_users_path, :params => { :users => user2.id, :format => "json" }, :oauth => { :token => good_token }
460       assert_response :success
461       assert_equal "application/json", response.media_type
462       js = ActiveSupport::JSON.decode(@response.body)
463       assert_not_nil js
464       assert_equal 1, js["users"].count
465       check_json_details(js["users"][0], user2, false)
466
467       signed_get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :oauth => { :token => good_token }
468       assert_response :success
469       assert_equal "application/json", response.media_type
470       js = ActiveSupport::JSON.decode(@response.body)
471       assert_not_nil js
472       assert_equal 2, js["users"].count
473       check_json_details(js["users"][0], user1, true)
474       check_json_details(js["users"][1], user3, false)
475
476       signed_get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :oauth => { :token => bad_token }
477       assert_response :success
478       assert_equal "application/json", response.media_type
479       js = ActiveSupport::JSON.decode(@response.body)
480       assert_not_nil js
481       assert_equal 2, js["users"].count
482       check_json_details(js["users"][0], user1, false)
483       check_json_details(js["users"][1], user3, false)
484
485       signed_get api_users_path, :params => { :users => create(:user, :suspended).id }, :oauth => { :token => good_token }
486       assert_response :not_found
487
488       signed_get api_users_path, :params => { :users => create(:user, :deleted).id }, :oauth => { :token => good_token }
489       assert_response :not_found
490
491       signed_get api_users_path, :params => { :users => 0 }, :oauth => { :token => good_token }
492       assert_response :not_found
493     end
494
495     def test_index_oauth2
496       user1 = create(:user, :description => "test1", :terms_agreed => Date.yesterday)
497       user2 = create(:user, :description => "test2", :terms_agreed => Date.yesterday)
498       user3 = create(:user, :description => "test3", :terms_agreed => Date.yesterday)
499       good_token = create(:oauth_access_token, :resource_owner_id => user1.id, :scopes => %w[read_prefs])
500       bad_token = create(:oauth_access_token, :resource_owner_id => user1.id, :scopes => %w[])
501
502       get api_users_path, :params => { :users => user1.id }, :headers => bearer_authorization_header(good_token.token)
503       assert_response :success
504       assert_equal "application/xml", response.media_type
505       assert_select "user", :count => 1 do
506         check_xml_details(user1, true)
507         assert_select "user[id='#{user2.id}']", :count => 0
508         assert_select "user[id='#{user3.id}']", :count => 0
509       end
510
511       get api_users_path, :params => { :users => user2.id }, :headers => bearer_authorization_header(good_token.token)
512       assert_response :success
513       assert_equal "application/xml", response.media_type
514       assert_select "user", :count => 1 do
515         assert_select "user[id='#{user1.id}']", :count => 0
516         check_xml_details(user2, false)
517         assert_select "user[id='#{user3.id}']", :count => 0
518       end
519
520       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :headers => bearer_authorization_header(good_token.token)
521       assert_response :success
522       assert_equal "application/xml", response.media_type
523       assert_select "user", :count => 2 do
524         check_xml_details(user1, true)
525         assert_select "user[id='#{user2.id}']", :count => 0
526         check_xml_details(user3, false)
527       end
528
529       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :headers => bearer_authorization_header(bad_token.token)
530       assert_response :success
531       assert_equal "application/xml", response.media_type
532       assert_select "user", :count => 2 do
533         check_xml_details(user1, false)
534         assert_select "user[id='#{user2.id}']", :count => 0
535         check_xml_details(user3, false)
536       end
537
538       get api_users_path, :params => { :users => user1.id, :format => "json" }, :headers => bearer_authorization_header(good_token.token)
539       assert_response :success
540       assert_equal "application/json", response.media_type
541       js = ActiveSupport::JSON.decode(@response.body)
542       assert_not_nil js
543       assert_equal 1, js["users"].count
544       check_json_details(js["users"][0], user1, true)
545
546       get api_users_path, :params => { :users => user2.id, :format => "json" }, :headers => bearer_authorization_header(good_token.token)
547       assert_response :success
548       assert_equal "application/json", response.media_type
549       js = ActiveSupport::JSON.decode(@response.body)
550       assert_not_nil js
551       assert_equal 1, js["users"].count
552       check_json_details(js["users"][0], user2, false)
553
554       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :headers => bearer_authorization_header(good_token.token)
555       assert_response :success
556       assert_equal "application/json", response.media_type
557       js = ActiveSupport::JSON.decode(@response.body)
558       assert_not_nil js
559       assert_equal 2, js["users"].count
560       check_json_details(js["users"][0], user1, true)
561       check_json_details(js["users"][1], user3, false)
562
563       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :headers => bearer_authorization_header(bad_token.token)
564       assert_response :success
565       assert_equal "application/json", response.media_type
566       js = ActiveSupport::JSON.decode(@response.body)
567       assert_not_nil js
568       assert_equal 2, js["users"].count
569       check_json_details(js["users"][0], user1, false)
570       check_json_details(js["users"][1], user3, false)
571
572       get api_users_path, :params => { :users => create(:user, :suspended).id }, :headers => bearer_authorization_header(good_token.token)
573       assert_response :not_found
574
575       get api_users_path, :params => { :users => create(:user, :deleted).id }, :headers => bearer_authorization_header(good_token.token)
576       assert_response :not_found
577
578       get api_users_path, :params => { :users => 0 }, :headers => bearer_authorization_header(good_token.token)
579       assert_response :not_found
580     end
581
582     def test_gpx_files
583       user = create(:user)
584       trace1 = create(:trace, :user => user) do |trace|
585         create(:tracetag, :trace => trace, :tag => "London")
586       end
587       trace2 = create(:trace, :user => user) do |trace|
588         create(:tracetag, :trace => trace, :tag => "Birmingham")
589       end
590       # check that nothing is returned when not logged in
591       get user_gpx_files_path
592       assert_response :unauthorized
593
594       # check that we get a response when logged in
595       auth_header = basic_authorization_header user.email, "test"
596       get user_gpx_files_path, :headers => auth_header
597       assert_response :success
598       assert_equal "application/xml", response.media_type
599
600       # check the data that is returned
601       assert_select "gpx_file[id='#{trace1.id}']", 1 do
602         assert_select "tag", "London"
603       end
604       assert_select "gpx_file[id='#{trace2.id}']", 1 do
605         assert_select "tag", "Birmingham"
606       end
607     end
608
609     private
610
611     def check_xml_details(user, include_private)
612       assert_select "user[id='#{user.id}']", :count => 1 do
613         assert_select "description", :count => 1, :text => user.description
614
615         assert_select "contributor-terms", :count => 1 do
616           if user.terms_agreed.present?
617             assert_select "[agreed='true']", :count => 1
618           else
619             assert_select "[agreed='false']", :count => 1
620           end
621
622           if include_private
623             assert_select "[pd='false']", :count => 1
624           else
625             assert_select "[pd]", :count => 0
626           end
627         end
628
629         assert_select "img", :count => 0
630
631         assert_select "roles", :count => 1 do
632           assert_select "role", :count => 0
633         end
634
635         assert_select "changesets", :count => 1 do
636           assert_select "[count='0']", :count => 1
637         end
638
639         assert_select "traces", :count => 1 do
640           assert_select "[count='0']", :count => 1
641         end
642
643         assert_select "blocks", :count => 1 do
644           assert_select "received", :count => 1 do
645             assert_select "[count='0'][active='0']", :count => 1
646           end
647
648           assert_select "issued", :count => 0
649         end
650
651         if include_private && user.home_lat.present? && user.home_lon.present?
652           assert_select "home", :count => 1 do
653             assert_select "[lat='12.1'][lon='23.4'][zoom='3']", :count => 1
654           end
655         else
656           assert_select "home", :count => 0
657         end
658
659         if include_private
660           assert_select "languages", :count => 1 do
661             assert_select "lang", :count => user.languages.count
662
663             user.languages.each do |language|
664               assert_select "lang", :count => 1, :text => language
665             end
666           end
667
668           assert_select "messages", :count => 1 do
669             assert_select "received", :count => 1 do
670               assert_select "[count='#{user.messages.count}'][unread='0']", :count => 1
671             end
672
673             assert_select "sent", :count => 1 do
674               assert_select "[count='#{user.sent_messages.count}']", :count => 1
675             end
676           end
677         else
678           assert_select "languages", :count => 0
679           assert_select "messages", :count => 0
680         end
681       end
682     end
683
684     def check_json_details(js, user, include_private)
685       assert_equal user.id, js["user"]["id"]
686       assert_equal user.description, js["user"]["description"]
687       assert js["user"]["contributor_terms"]["agreed"]
688
689       if include_private
690         assert_not js["user"]["contributor_terms"]["pd"]
691       else
692         assert_nil js["user"]["contributor_terms"]["pd"]
693       end
694
695       assert_nil js["user"]["img"]
696       assert_empty js["user"]["roles"]
697       assert_equal 0, js["user"]["changesets"]["count"]
698       assert_equal 0, js["user"]["traces"]["count"]
699       assert_equal 0, js["user"]["blocks"]["received"]["count"]
700       assert_equal 0, js["user"]["blocks"]["received"]["active"]
701       assert_nil js["user"]["blocks"]["issued"]
702
703       if include_private && user.home_lat.present? && user.home_lon.present?
704         assert_in_delta 12.1, js["user"]["home"]["lat"]
705         assert_in_delta 23.4, js["user"]["home"]["lon"]
706         assert_equal 3, js["user"]["home"]["zoom"]
707       else
708         assert_nil js["user"]["home"]
709       end
710
711       if include_private && user.languages.present?
712         assert_equal user.languages, js["user"]["languages"]
713       else
714         assert_nil js["user"]["languages"]
715       end
716
717       if include_private
718         assert_equal user.messages.count, js["user"]["messages"]["received"]["count"]
719         assert_equal 0, js["user"]["messages"]["received"]["unread"]
720         assert_equal user.sent_messages.count, js["user"]["messages"]["sent"]["count"]
721       else
722         assert_nil js["user"]["messages"]
723       end
724     end
725   end
726 end