test/controllers/user_preferences_controller_test.rb

   1 require "test_helper"
   2
   3 class UserPreferencesControllerTest < ActionController::TestCase
   4   ##
   5   # test all routes which lead to this controller
   6   def test_routes
   7     assert_routing(
   8       { :path => "/api/0.6/user/preferences", :method => :get },
   9       { :controller => "user_preferences", :action => "read" }
  10     )
  11     assert_routing(
  12       { :path => "/api/0.6/user/preferences", :method => :put },
  13       { :controller => "user_preferences", :action => "update" }
  14     )
  15     assert_routing(
  16       { :path => "/api/0.6/user/preferences/key", :method => :get },
  17       { :controller => "user_preferences", :action => "read_one", :preference_key => "key" }
  18     )
  19     assert_routing(
  20       { :path => "/api/0.6/user/preferences/key", :method => :put },
  21       { :controller => "user_preferences", :action => "update_one", :preference_key => "key" }
  22     )
  23     assert_routing(
  24       { :path => "/api/0.6/user/preferences/key", :method => :delete },
  25       { :controller => "user_preferences", :action => "delete_one", :preference_key => "key" }
  26     )
  27   end
  28
  29   ##
  30   # test read action
  31   def test_read
  32     # first try without auth
  33     get :read
  34     assert_response :unauthorized, "should be authenticated"
  35
  36     # authenticate as a user with no preferences
  37     basic_authorization create(:user).email, "test"
  38
  39     # try the read again
  40     get :read
  41     assert_select "osm" do
  42       assert_select "preferences", :count => 1 do
  43         assert_select "preference", :count => 0
  44       end
  45     end
  46
  47     # authenticate as a user with preferences
  48     user = create(:user)
  49     user_preference = create(:user_preference, :user => user)
  50     user_preference2 = create(:user_preference, :user => user)
  51     basic_authorization user.email, "test"
  52
  53     # try the read again
  54     get :read
  55     assert_response :success
  56     assert_equal "application/xml", @response.content_type
  57     assert_select "osm" do
  58       assert_select "preferences", :count => 1 do
  59         assert_select "preference", :count => 2
  60         assert_select "preference[k=\"#{user_preference.k}\"][v=\"#{user_preference.v}\"]", :count => 1
  61         assert_select "preference[k=\"#{user_preference2.k}\"][v=\"#{user_preference2.v}\"]", :count => 1
  62       end
  63     end
  64   end
  65
  66   ##
  67   # test read_one action
  68   def test_read_one
  69     user = create(:user)
  70     create(:user_preference, :user => user, :k => "key", :v => "value")
  71
  72     # try a read without auth
  73     get :read_one, :params => { :preference_key => "key" }
  74     assert_response :unauthorized, "should be authenticated"
  75
  76     # authenticate as a user with preferences
  77     basic_authorization user.email, "test"
  78
  79     # try the read again
  80     get :read_one, :params => { :preference_key => "key" }
  81     assert_response :success
  82     assert_equal "text/plain", @response.content_type
  83     assert_equal "value", @response.body
  84
  85     # try the read again for a non-existent key
  86     get :read_one, :params => { :preference_key => "unknown_key" }
  87     assert_response :not_found
  88   end
  89
  90   ##
  91   # test update action
  92   def test_update
  93     user = create(:user)
  94     create(:user_preference, :user => user, :k => "key", :v => "value")
  95     create(:user_preference, :user => user, :k => "some_key", :v => "some_value")
  96
  97     # try a put without auth
  98     assert_no_difference "UserPreference.count" do
  99       put :update, :body => "<osm><preferences><preference k='key' v='new_value'/><preference k='new_key' v='value'/></preferences></osm>"
 100     end
 101     assert_response :unauthorized, "should be authenticated"
 102     assert_equal "value", UserPreference.find([user.id, "key"]).v
 103     assert_equal "some_value", UserPreference.find([user.id, "some_key"]).v
 104     assert_raises ActiveRecord::RecordNotFound do
 105       UserPreference.find([user.id, "new_key"])
 106     end
 107
 108     # authenticate as a user with preferences
 109     basic_authorization user.email, "test"
 110
 111     # try the put again
 112     assert_no_difference "UserPreference.count" do
 113       put :update, :body => "<osm><preferences><preference k='key' v='new_value'/><preference k='new_key' v='value'/></preferences></osm>"
 114     end
 115     assert_response :success
 116     assert_equal "text/plain", @response.content_type
 117     assert_equal "", @response.body
 118     assert_equal "new_value", UserPreference.find([user.id, "key"]).v
 119     assert_equal "value", UserPreference.find([user.id, "new_key"]).v
 120     assert_raises ActiveRecord::RecordNotFound do
 121       UserPreference.find([user.id, "some_key"])
 122     end
 123
 124     # try a put with duplicate keys
 125     assert_no_difference "UserPreference.count" do
 126       put :update, :body => "<osm><preferences><preference k='key' v='value'/><preference k='key' v='newer_value'/></preferences></osm>"
 127     end
 128     assert_response :bad_request
 129     assert_equal "text/plain", @response.content_type
 130     assert_equal "Duplicate preferences with key key", @response.body
 131     assert_equal "new_value", UserPreference.find([user.id, "key"]).v
 132
 133     # try a put with invalid content
 134     assert_no_difference "UserPreference.count" do
 135       put :update, :body => "nonsense"
 136     end
 137     assert_response :bad_request
 138   end
 139
 140   ##
 141   # test update_one action
 142   def test_update_one
 143     user = create(:user)
 144     create(:user_preference, :user => user)
 145
 146     # try a put without auth
 147     assert_no_difference "UserPreference.count" do
 148       put :update_one, :params => { :preference_key => "new_key" }, :body => "new_value"
 149     end
 150     assert_response :unauthorized, "should be authenticated"
 151     assert_raises ActiveRecord::RecordNotFound do
 152       UserPreference.find([user.id, "new_key"])
 153     end
 154
 155     # authenticate as a user with preferences
 156     basic_authorization user.email, "test"
 157
 158     # try adding a new preference
 159     assert_difference "UserPreference.count", 1 do
 160       put :update_one, :params => { :preference_key => "new_key" }, :body => "new_value"
 161     end
 162     assert_response :success
 163     assert_equal "text/plain", @response.content_type
 164     assert_equal "", @response.body
 165     assert_equal "new_value", UserPreference.find([user.id, "new_key"]).v
 166
 167     # try changing the value of a preference
 168     assert_no_difference "UserPreference.count" do
 169       put :update_one, :params => { :preference_key => "new_key" }, :body => "newer_value"
 170     end
 171     assert_response :success
 172     assert_equal "text/plain", @response.content_type
 173     assert_equal "", @response.body
 174     assert_equal "newer_value", UserPreference.find([user.id, "new_key"]).v
 175   end
 176
 177   ##
 178   # test delete_one action
 179   def test_delete_one
 180     user = create(:user)
 181     create(:user_preference, :user => user, :k => "key", :v => "value")
 182
 183     # try a delete without auth
 184     assert_no_difference "UserPreference.count" do
 185       delete :delete_one, :params => { :preference_key => "key" }
 186     end
 187     assert_response :unauthorized, "should be authenticated"
 188     assert_equal "value", UserPreference.find([user.id, "key"]).v
 189
 190     # authenticate as a user with preferences
 191     basic_authorization user.email, "test"
 192
 193     # try the delete again
 194     assert_difference "UserPreference.count", -1 do
 195       get :delete_one, :params => { :preference_key => "key" }
 196     end
 197     assert_response :success
 198     assert_equal "text/plain", @response.content_type
 199     assert_equal "", @response.body
 200     assert_raises ActiveRecord::RecordNotFound do
 201       UserPreference.find([user.id, "key"])
 202     end
 203
 204     # try the delete again for the same key
 205     assert_no_difference "UserPreference.count" do
 206       get :delete_one, :params => { :preference_key => "key" }
 207     end
 208     assert_response :not_found
 209     assert_raises ActiveRecord::RecordNotFound do
 210       UserPreference.find([user.id, "key"])
 211     end
 212   end
 213
 214   # Ensure that a valid access token with correct capabilities can be used to
 215   # read preferences
 216   def test_read_one_using_token
 217     user = create(:user)
 218     token = create(:access_token, :user => user, :allow_read_prefs => true)
 219     create(:user_preference, :user => user, :k => "key", :v => "value")
 220
 221     # Hack together an oauth request - an alternative would be to sign the request properly
 222     @request.env["oauth.version"] = 1
 223     @request.env["oauth.strategies"] = [:token]
 224     @request.env["oauth.token"] = token
 225
 226     get :read_one, :params => { :preference_key => "key" }
 227     assert_response :success
 228   end
 229
 230   # Ensure that a valid access token with incorrect capabilities can't be used
 231   # to read preferences even, though the owner of that token could read them
 232   # by other methods.
 233   def test_read_one_using_token_fail
 234     user = create(:user)
 235     token = create(:access_token, :user => user, :allow_read_prefs => false)
 236     create(:user_preference, :user => user, :k => "key", :v => "value")
 237     @request.env["oauth.version"] = 1
 238     @request.env["oauth.strategies"] = [:token]
 239     @request.env["oauth.token"] = token
 240
 241     get :read_one, :params => { :preference_key => "key" }
 242     assert_response :forbidden
 243   end
 244 end