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, 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, false)
  76     end
  77
  78     def test_show_oauth2
  79       user = create(:user,
  80                     :home_lat => 12.1, :home_lon => 23.4,
  81                     :languages => ["en"])
  82       good_token = create(:oauth_access_token,
  83                           :resource_owner_id => user.id,
  84                           :scopes => %w[read_prefs])
  85       bad_token = create(:oauth_access_token,
  86                          :resource_owner_id => user.id,
  87                          :scopes => %w[])
  88       other_user = create(:user,
  89                           :home_lat => 12.1, :home_lon => 23.4,
  90                           :languages => ["en"])
  91
  92       # check that we can fetch our own details as XML with read_prefs
  93       get api_user_path(:id => user.id), :headers => bearer_authorization_header(good_token.token)
  94       assert_response :success
  95       assert_equal "application/xml", response.media_type
  96
  97       # check the data that is returned
  98       check_xml_details(user, true, false)
  99
 100       # check that we can fetch a different user's details as XML with read_prefs
 101       get api_user_path(:id => other_user.id), :headers => bearer_authorization_header(good_token.token)
 102       assert_response :success
 103       assert_equal "application/xml", response.media_type
 104
 105       # check the data that is returned
 106       check_xml_details(other_user, false, false)
 107
 108       # check that we can fetch our own details as XML without read_prefs
 109       get api_user_path(:id => user.id), :headers => bearer_authorization_header(bad_token.token)
 110       assert_response :success
 111       assert_equal "application/xml", response.media_type
 112
 113       # check the data that is returned
 114       check_xml_details(user, false, false)
 115
 116       # check that we can fetch our own details as JSON with read_prefs
 117       get api_user_path(:id => user.id, :format => "json"), :headers => bearer_authorization_header(good_token.token)
 118       assert_response :success
 119       assert_equal "application/json", response.media_type
 120
 121       # parse the response
 122       js = ActiveSupport::JSON.decode(@response.body)
 123       assert_not_nil js
 124
 125       # check the data that is returned
 126       check_json_details(js, user, true, false)
 127
 128       # check that we can fetch a different user's details as JSON with read_prefs
 129       get api_user_path(:id => other_user.id, :format => "json"), :headers => bearer_authorization_header(good_token.token)
 130       assert_response :success
 131       assert_equal "application/json", response.media_type
 132
 133       # parse the response
 134       js = ActiveSupport::JSON.decode(@response.body)
 135       assert_not_nil js
 136
 137       # check the data that is returned
 138       check_json_details(js, other_user, false, false)
 139
 140       # check that we can fetch our own details as JSON without read_prefs
 141       get api_user_path(:id => user.id, :format => "json"), :headers => bearer_authorization_header(bad_token.token)
 142       assert_response :success
 143       assert_equal "application/json", response.media_type
 144
 145       # parse the response
 146       js = ActiveSupport::JSON.decode(@response.body)
 147       assert_not_nil js
 148
 149       # check the data that is returned
 150       check_json_details(js, user, false, false)
 151     end
 152
 153     def test_details
 154       user = create(:user,
 155                     :description => "test",
 156                     :terms_agreed => Date.yesterday,
 157                     :home_lat => 12.1, :home_lon => 23.4,
 158                     :languages => ["en"])
 159       create(:message, :read, :recipient => user)
 160       create(:message, :sender => user)
 161
 162       # check that nothing is returned when not logged in
 163       get user_details_path
 164       assert_response :unauthorized
 165
 166       # check that we get a response when logged in
 167       auth_header = basic_authorization_header user.email, "test"
 168       get user_details_path, :headers => auth_header
 169       assert_response :success
 170       assert_equal "application/xml", response.media_type
 171
 172       # check the data that is returned
 173       check_xml_details(user, true, false)
 174
 175       # check that data is returned properly in json
 176       auth_header = basic_authorization_header user.email, "test"
 177       get user_details_path(:format => "json"), :headers => auth_header
 178       assert_response :success
 179       assert_equal "application/json", response.media_type
 180
 181       # parse the response
 182       js = ActiveSupport::JSON.decode(@response.body)
 183       assert_not_nil js
 184
 185       # check the data that is returned
 186       check_json_details(js, user, true, false)
 187     end
 188
 189     def test_details_oauth2
 190       user = create(:user,
 191                     :home_lat => 12.1, :home_lon => 23.4,
 192                     :languages => ["en"])
 193       good_token = create(:oauth_access_token,
 194                           :resource_owner_id => user.id,
 195                           :scopes => %w[read_prefs])
 196       bad_token = create(:oauth_access_token,
 197                          :resource_owner_id => user.id)
 198       email_token = create(:oauth_access_token,
 199                            :resource_owner_id => user.id,
 200                            :scopes => %w[read_prefs read_email])
 201
 202       # check that we can't fetch details as XML without read_prefs
 203       get user_details_path, :headers => bearer_authorization_header(bad_token.token)
 204       assert_response :forbidden
 205
 206       # check that we can fetch details as XML without read_email
 207       get user_details_path, :headers => bearer_authorization_header(good_token.token)
 208       assert_response :success
 209       assert_equal "application/xml", response.media_type
 210
 211       # check the data that is returned
 212       check_xml_details(user, true, false)
 213
 214       # check that we can fetch details as XML with read_email
 215       get user_details_path, :headers => bearer_authorization_header(email_token.token)
 216       assert_response :success
 217       assert_equal "application/xml", response.media_type
 218
 219       # check the data that is returned
 220       check_xml_details(user, true, true)
 221
 222       # check that we can't fetch details as JSON without read_prefs
 223       get user_details_path(:format => "json"), :headers => bearer_authorization_header(bad_token.token)
 224       assert_response :forbidden
 225
 226       # check that we can fetch details as JSON without read_email
 227       get user_details_path(:format => "json"), :headers => bearer_authorization_header(good_token.token)
 228       assert_response :success
 229       assert_equal "application/json", response.media_type
 230
 231       # parse the response
 232       js = ActiveSupport::JSON.decode(@response.body)
 233       assert_not_nil js
 234
 235       # check the data that is returned
 236       check_json_details(js, user, true, false)
 237
 238       # check that we can fetch details as JSON with read_email
 239       get user_details_path(:format => "json"), :headers => bearer_authorization_header(email_token.token)
 240       assert_response :success
 241       assert_equal "application/json", response.media_type
 242
 243       # parse the response
 244       js = ActiveSupport::JSON.decode(@response.body)
 245       assert_not_nil js
 246
 247       # check the data that is returned
 248       check_json_details(js, user, true, true)
 249     end
 250
 251     def test_index
 252       user1 = create(:user, :description => "test1", :terms_agreed => Date.yesterday)
 253       user2 = create(:user, :description => "test2", :terms_agreed => Date.yesterday)
 254       user3 = create(:user, :description => "test3", :terms_agreed => Date.yesterday)
 255
 256       get api_users_path, :params => { :users => user1.id }
 257       assert_response :success
 258       assert_equal "application/xml", response.media_type
 259       assert_select "user", :count => 1 do
 260         check_xml_details(user1, false, false)
 261         assert_select "user[id='#{user2.id}']", :count => 0
 262         assert_select "user[id='#{user3.id}']", :count => 0
 263       end
 264
 265       get api_users_path, :params => { :users => user2.id }
 266       assert_response :success
 267       assert_equal "application/xml", response.media_type
 268       assert_select "user", :count => 1 do
 269         assert_select "user[id='#{user1.id}']", :count => 0
 270         check_xml_details(user2, false, false)
 271         assert_select "user[id='#{user3.id}']", :count => 0
 272       end
 273
 274       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }
 275       assert_response :success
 276       assert_equal "application/xml", response.media_type
 277       assert_select "user", :count => 2 do
 278         check_xml_details(user1, false, false)
 279         assert_select "user[id='#{user2.id}']", :count => 0
 280         check_xml_details(user3, false, false)
 281       end
 282
 283       get api_users_path, :params => { :users => user1.id, :format => "json" }
 284       assert_response :success
 285       assert_equal "application/json", response.media_type
 286       js = ActiveSupport::JSON.decode(@response.body)
 287       assert_not_nil js
 288       assert_equal 1, js["users"].count
 289       check_json_details(js["users"][0], user1, false, false)
 290
 291       get api_users_path, :params => { :users => user2.id, :format => "json" }
 292       assert_response :success
 293       assert_equal "application/json", response.media_type
 294       js = ActiveSupport::JSON.decode(@response.body)
 295       assert_not_nil js
 296       assert_equal 1, js["users"].count
 297       check_json_details(js["users"][0], user2, false, false)
 298
 299       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }
 300       assert_response :success
 301       assert_equal "application/json", response.media_type
 302       js = ActiveSupport::JSON.decode(@response.body)
 303       assert_not_nil js
 304       assert_equal 2, js["users"].count
 305       check_json_details(js["users"][0], user1, false, false)
 306       check_json_details(js["users"][1], user3, false, false)
 307
 308       get api_users_path, :params => { :users => create(:user, :suspended).id }
 309       assert_response :success
 310       assert_equal "application/xml", response.media_type
 311       assert_select "user", :count => 0
 312
 313       get api_users_path, :params => { :users => create(:user, :deleted).id }
 314       assert_response :success
 315       assert_equal "application/xml", response.media_type
 316       assert_select "user", :count => 0
 317
 318       get api_users_path, :params => { :users => 0 }
 319       assert_response :success
 320       assert_equal "application/xml", response.media_type
 321       assert_select "user", :count => 0
 322     end
 323
 324     def test_index_oauth2
 325       user1 = create(:user, :description => "test1", :terms_agreed => Date.yesterday)
 326       user2 = create(:user, :description => "test2", :terms_agreed => Date.yesterday)
 327       user3 = create(:user, :description => "test3", :terms_agreed => Date.yesterday)
 328       good_token = create(:oauth_access_token, :resource_owner_id => user1.id, :scopes => %w[read_prefs])
 329       bad_token = create(:oauth_access_token, :resource_owner_id => user1.id, :scopes => %w[])
 330
 331       get api_users_path, :params => { :users => user1.id }, :headers => bearer_authorization_header(good_token.token)
 332       assert_response :success
 333       assert_equal "application/xml", response.media_type
 334       assert_select "user", :count => 1 do
 335         check_xml_details(user1, true, false)
 336         assert_select "user[id='#{user2.id}']", :count => 0
 337         assert_select "user[id='#{user3.id}']", :count => 0
 338       end
 339
 340       get api_users_path, :params => { :users => user2.id }, :headers => bearer_authorization_header(good_token.token)
 341       assert_response :success
 342       assert_equal "application/xml", response.media_type
 343       assert_select "user", :count => 1 do
 344         assert_select "user[id='#{user1.id}']", :count => 0
 345         check_xml_details(user2, false, false)
 346         assert_select "user[id='#{user3.id}']", :count => 0
 347       end
 348
 349       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :headers => bearer_authorization_header(good_token.token)
 350       assert_response :success
 351       assert_equal "application/xml", response.media_type
 352       assert_select "user", :count => 2 do
 353         check_xml_details(user1, true, false)
 354         assert_select "user[id='#{user2.id}']", :count => 0
 355         check_xml_details(user3, false, false)
 356       end
 357
 358       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}" }, :headers => bearer_authorization_header(bad_token.token)
 359       assert_response :success
 360       assert_equal "application/xml", response.media_type
 361       assert_select "user", :count => 2 do
 362         check_xml_details(user1, false, false)
 363         assert_select "user[id='#{user2.id}']", :count => 0
 364         check_xml_details(user3, false, false)
 365       end
 366
 367       get api_users_path, :params => { :users => user1.id, :format => "json" }, :headers => bearer_authorization_header(good_token.token)
 368       assert_response :success
 369       assert_equal "application/json", response.media_type
 370       js = ActiveSupport::JSON.decode(@response.body)
 371       assert_not_nil js
 372       assert_equal 1, js["users"].count
 373       check_json_details(js["users"][0], user1, true, false)
 374
 375       get api_users_path, :params => { :users => user2.id, :format => "json" }, :headers => bearer_authorization_header(good_token.token)
 376       assert_response :success
 377       assert_equal "application/json", response.media_type
 378       js = ActiveSupport::JSON.decode(@response.body)
 379       assert_not_nil js
 380       assert_equal 1, js["users"].count
 381       check_json_details(js["users"][0], user2, false, false)
 382
 383       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :headers => bearer_authorization_header(good_token.token)
 384       assert_response :success
 385       assert_equal "application/json", response.media_type
 386       js = ActiveSupport::JSON.decode(@response.body)
 387       assert_not_nil js
 388       assert_equal 2, js["users"].count
 389       check_json_details(js["users"][0], user1, true, false)
 390       check_json_details(js["users"][1], user3, false, false)
 391
 392       get api_users_path, :params => { :users => "#{user1.id},#{user3.id}", :format => "json" }, :headers => bearer_authorization_header(bad_token.token)
 393       assert_response :success
 394       assert_equal "application/json", response.media_type
 395       js = ActiveSupport::JSON.decode(@response.body)
 396       assert_not_nil js
 397       assert_equal 2, js["users"].count
 398       check_json_details(js["users"][0], user1, false, false)
 399       check_json_details(js["users"][1], user3, false, false)
 400
 401       get api_users_path, :params => { :users => create(:user, :suspended).id }, :headers => bearer_authorization_header(good_token.token)
 402       assert_response :success
 403       assert_equal "application/xml", response.media_type
 404       assert_select "user", :count => 0
 405
 406       get api_users_path, :params => { :users => create(:user, :deleted).id }, :headers => bearer_authorization_header(good_token.token)
 407       assert_response :success
 408       assert_equal "application/xml", response.media_type
 409       assert_select "user", :count => 0
 410
 411       get api_users_path, :params => { :users => 0 }, :headers => bearer_authorization_header(good_token.token)
 412       assert_response :success
 413       assert_equal "application/xml", response.media_type
 414       assert_select "user", :count => 0
 415     end
 416
 417     def test_gpx_files
 418       user = create(:user)
 419       trace1 = create(:trace, :user => user) do |trace|
 420         create(:tracetag, :trace => trace, :tag => "London")
 421       end
 422       trace2 = create(:trace, :user => user) do |trace|
 423         create(:tracetag, :trace => trace, :tag => "Birmingham")
 424       end
 425       # check that nothing is returned when not logged in
 426       get user_gpx_files_path
 427       assert_response :unauthorized
 428
 429       # check that we get a response when logged in
 430       auth_header = basic_authorization_header user.email, "test"
 431       get user_gpx_files_path, :headers => auth_header
 432       assert_response :success
 433       assert_equal "application/xml", response.media_type
 434
 435       # check the data that is returned
 436       assert_select "gpx_file[id='#{trace1.id}']", 1 do
 437         assert_select "tag", "London"
 438       end
 439       assert_select "gpx_file[id='#{trace2.id}']", 1 do
 440         assert_select "tag", "Birmingham"
 441       end
 442     end
 443
 444     private
 445
 446     def check_xml_details(user, include_private, include_email)
 447       assert_select "user[id='#{user.id}']", :count => 1 do
 448         assert_select "description", :count => 1, :text => user.description
 449
 450         assert_select "contributor-terms", :count => 1 do
 451           if user.terms_agreed.present?
 452             assert_select "[agreed='true']", :count => 1
 453           else
 454             assert_select "[agreed='false']", :count => 1
 455           end
 456
 457           if include_private
 458             assert_select "[pd='false']", :count => 1
 459           else
 460             assert_select "[pd]", :count => 0
 461           end
 462         end
 463
 464         assert_select "img", :count => 0
 465
 466         assert_select "roles", :count => 1 do
 467           assert_select "role", :count => 0
 468         end
 469
 470         assert_select "changesets", :count => 1 do
 471           assert_select "[count='0']", :count => 1
 472         end
 473
 474         assert_select "traces", :count => 1 do
 475           assert_select "[count='0']", :count => 1
 476         end
 477
 478         assert_select "blocks", :count => 1 do
 479           assert_select "received", :count => 1 do
 480             assert_select "[count='0'][active='0']", :count => 1
 481           end
 482
 483           assert_select "issued", :count => 0
 484         end
 485
 486         if include_private && user.home_lat.present? && user.home_lon.present?
 487           assert_select "home", :count => 1 do
 488             assert_select "[lat='12.1'][lon='23.4'][zoom='3']", :count => 1
 489           end
 490         else
 491           assert_select "home", :count => 0
 492         end
 493
 494         if include_private
 495           assert_select "languages", :count => 1 do
 496             assert_select "lang", :count => user.languages.count
 497
 498             user.languages.each do |language|
 499               assert_select "lang", :count => 1, :text => language
 500             end
 501           end
 502
 503           assert_select "messages", :count => 1 do
 504             assert_select "received", :count => 1 do
 505               assert_select "[count='#{user.messages.count}'][unread='0']", :count => 1
 506             end
 507
 508             assert_select "sent", :count => 1 do
 509               assert_select "[count='#{user.sent_messages.count}']", :count => 1
 510             end
 511           end
 512         else
 513           assert_select "languages", :count => 0
 514           assert_select "messages", :count => 0
 515         end
 516
 517         if include_email
 518           assert_select "email", :count => 1, :text => user.email
 519         else
 520           assert_select "email", :count => 0
 521         end
 522       end
 523     end
 524
 525     def check_json_details(js, user, include_private, include_email)
 526       assert_equal user.id, js["user"]["id"]
 527       assert_equal user.description, js["user"]["description"]
 528       assert_operator js["user"]["contributor_terms"], :[], "agreed"
 529
 530       if include_private
 531         assert_not js["user"]["contributor_terms"]["pd"]
 532       else
 533         assert_nil js["user"]["contributor_terms"]["pd"]
 534       end
 535
 536       assert_nil js["user"]["img"]
 537       assert_empty js["user"]["roles"]
 538       assert_equal 0, js["user"]["changesets"]["count"]
 539       assert_equal 0, js["user"]["traces"]["count"]
 540       assert_equal 0, js["user"]["blocks"]["received"]["count"]
 541       assert_equal 0, js["user"]["blocks"]["received"]["active"]
 542       assert_nil js["user"]["blocks"]["issued"]
 543
 544       if include_private && user.home_lat.present? && user.home_lon.present?
 545         assert_in_delta 12.1, js["user"]["home"]["lat"]
 546         assert_in_delta 23.4, js["user"]["home"]["lon"]
 547         assert_equal 3, js["user"]["home"]["zoom"]
 548       else
 549         assert_nil js["user"]["home"]
 550       end
 551
 552       if include_private && user.languages.present?
 553         assert_equal user.languages, js["user"]["languages"]
 554       else
 555         assert_nil js["user"]["languages"]
 556       end
 557
 558       if include_private
 559         assert_equal user.messages.count, js["user"]["messages"]["received"]["count"]
 560         assert_equal 0, js["user"]["messages"]["received"]["unread"]
 561         assert_equal user.sent_messages.count, js["user"]["messages"]["sent"]["count"]
 562       else
 563         assert_nil js["user"]["messages"]
 564       end
 565
 566       if include_email
 567         assert_equal user.email, js["user"]["email"]
 568       else
 569         assert_nil js["user"]["email"]
 570       end
 571     end
 572   end
 573 end