test/controllers/api/messages_controller_test.rb

   1 require "test_helper"
   2
   3 module Api
   4   class MessagesControllerTest < 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/messages/1", :method => :get },
  10         { :controller => "api/messages", :action => "show", :id => "1" }
  11       )
  12       assert_routing(
  13         { :path => "/api/0.6/user/messages/1.xml", :method => :get },
  14         { :controller => "api/messages", :action => "show", :id => "1", :format => "xml" }
  15       )
  16       assert_routing(
  17         { :path => "/api/0.6/user/messages/1.json", :method => :get },
  18         { :controller => "api/messages", :action => "show", :id => "1", :format => "json" }
  19       )
  20       assert_routing(
  21         { :path => "/api/0.6/user/messages", :method => :post },
  22         { :controller => "api/messages", :action => "create" }
  23       )
  24       assert_routing(
  25         { :path => "/api/0.6/user/messages/1", :method => :put },
  26         { :controller => "api/messages", :action => "update", :id => "1" }
  27       )
  28       assert_recognizes(
  29         { :controller => "api/messages", :action => "update", :id => "1" },
  30         { :path => "/api/0.6/user/messages/1", :method => :post }
  31       )
  32       assert_routing(
  33         { :path => "/api/0.6/user/messages/1", :method => :delete },
  34         { :controller => "api/messages", :action => "destroy", :id => "1" }
  35       )
  36     end
  37
  38     def test_create_success
  39       recipient = create(:user)
  40       sender = create(:user)
  41
  42       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
  43
  44       msg = build(:message)
  45
  46       assert_difference "Message.count", 1 do
  47         assert_difference "ActionMailer::Base.deliveries.size", 1 do
  48           perform_enqueued_jobs do
  49             post api_messages_path,
  50                  :params => { :title => msg.title,
  51                               :recipient_id => recipient.id,
  52                               :body => msg.body,
  53                               :format => "json" },
  54                  :headers => sender_auth
  55             assert_response :success
  56           end
  57         end
  58       end
  59
  60       assert_equal "application/json", response.media_type
  61       js = ActiveSupport::JSON.decode(@response.body)
  62       jsm = js["message"]
  63       assert_not_nil jsm
  64       assert_not_nil jsm["id"]
  65       assert_equal sender.id, jsm["from_user_id"]
  66       assert_equal sender.display_name, jsm["from_display_name"]
  67       assert_equal recipient.id, jsm["to_user_id"]
  68       assert_equal recipient.display_name, jsm["to_display_name"]
  69       assert_equal msg.title, jsm["title"]
  70       assert_not_nil jsm["sent_on"]
  71       assert_equal !msg.from_user_visible, jsm["deleted"]
  72       assert_not jsm.key?("message_read")
  73       assert_equal "markdown", jsm["body_format"]
  74       assert_equal msg.body, jsm["body"]
  75     end
  76
  77     def test_create_fail
  78       recipient = create(:user)
  79
  80       sender = create(:user)
  81       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
  82
  83       assert_no_difference "Message.count" do
  84         assert_no_difference "ActionMailer::Base.deliveries.size" do
  85           perform_enqueued_jobs do
  86             post api_messages_path,
  87                  :params => { :title => "Title",
  88                               :recipient_id => recipient.id,
  89                               :body => "body" }
  90           end
  91         end
  92       end
  93       assert_response :unauthorized
  94
  95       assert_no_difference "Message.count" do
  96         assert_no_difference "ActionMailer::Base.deliveries.size" do
  97           perform_enqueued_jobs do
  98             post api_messages_path,
  99                  :params => { :recipient_id => recipient.id,
 100                               :body => "body" },
 101                  :headers => sender_auth
 102           end
 103         end
 104       end
 105       assert_response :bad_request
 106
 107       assert_no_difference "Message.count" do
 108         assert_no_difference "ActionMailer::Base.deliveries.size" do
 109           perform_enqueued_jobs do
 110             post api_messages_path,
 111                  :params => { :title => "Title",
 112                               :body => "body" },
 113                  :headers => sender_auth
 114           end
 115         end
 116       end
 117       assert_response :bad_request
 118
 119       assert_no_difference "Message.count" do
 120         assert_no_difference "ActionMailer::Base.deliveries.size" do
 121           perform_enqueued_jobs do
 122             post api_messages_path,
 123                  :params => { :title => "Title",
 124                               :recipient_id => recipient.id },
 125                  :headers => sender_auth
 126           end
 127         end
 128       end
 129       assert_response :bad_request
 130     end
 131
 132     def test_show
 133       recipient = create(:user)
 134       sender = create(:user)
 135       user3 = create(:user)
 136
 137       sender_auth = bearer_authorization_header(sender, :scopes => %w[consume_messages])
 138       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
 139       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
 140
 141       msg = create(:message, :unread, :sender => sender, :recipient => recipient)
 142
 143       # fail if not authorized
 144       get api_message_path(msg)
 145       assert_response :unauthorized
 146
 147       # only recipient and sender can read the message
 148       get api_message_path(msg), :headers => user3_auth
 149       assert_response :forbidden
 150
 151       # message does not exist
 152       get api_message_path(99999), :headers => user3_auth
 153       assert_response :not_found
 154
 155       # verify xml output
 156       get api_message_path(msg), :headers => recipient_auth
 157       assert_equal "application/xml", response.media_type
 158       assert_select "message", :count => 1 do
 159         assert_select "[id='#{msg.id}']"
 160         assert_select "[from_user_id='#{sender.id}']"
 161         assert_select "[from_display_name='#{sender.display_name}']"
 162         assert_select "[to_user_id='#{recipient.id}']"
 163         assert_select "[to_display_name='#{recipient.display_name}']"
 164         assert_select "[sent_on]"
 165         assert_select "[deleted='#{!msg.to_user_visible}']"
 166         assert_select "[message_read='#{msg.message_read}']"
 167         assert_select "[body_format='markdown']"
 168         assert_select "title", msg.title
 169         assert_select "body", msg.body
 170       end
 171
 172       # verify json output
 173       get api_message_path(msg, :format => "json"), :headers => recipient_auth
 174       assert_equal "application/json", response.media_type
 175       js = ActiveSupport::JSON.decode(@response.body)
 176       jsm = js["message"]
 177       assert_not_nil jsm
 178       assert_equal msg.id, jsm["id"]
 179       assert_equal sender.id, jsm["from_user_id"]
 180       assert_equal sender.display_name, jsm["from_display_name"]
 181       assert_equal recipient.id, jsm["to_user_id"]
 182       assert_equal recipient.display_name, jsm["to_display_name"]
 183       assert_equal msg.title, jsm["title"]
 184       assert_not_nil jsm["sent_on"]
 185       assert_equal msg.message_read, jsm["message_read"]
 186       assert_equal !msg.to_user_visible, jsm["deleted"]
 187       assert_equal "markdown", jsm["body_format"]
 188       assert_equal msg.body, jsm["body"]
 189
 190       get api_message_path(msg), :headers => sender_auth
 191       assert_equal "application/xml", response.media_type
 192       assert_select "message", :count => 1 do
 193         assert_select "[id='#{msg.id}']"
 194         assert_select "[from_user_id='#{sender.id}']"
 195         assert_select "[from_display_name='#{sender.display_name}']"
 196         assert_select "[to_user_id='#{recipient.id}']"
 197         assert_select "[to_display_name='#{recipient.display_name}']"
 198         assert_select "[sent_on]"
 199         assert_select "[deleted='#{!msg.from_user_visible}']"
 200         assert_select "[message_read='#{msg.message_read}']", 0
 201         assert_select "[body_format='markdown']"
 202         assert_select "title", msg.title
 203         assert_select "body", msg.body
 204       end
 205
 206       # verify json output
 207       get api_message_path(msg, :format => "json"), :headers => sender_auth
 208       assert_equal "application/json", response.media_type
 209       js = ActiveSupport::JSON.decode(@response.body)
 210       jsm = js["message"]
 211       assert_not_nil jsm
 212       assert_equal msg.id, jsm["id"]
 213       assert_equal sender.id, jsm["from_user_id"]
 214       assert_equal sender.display_name, jsm["from_display_name"]
 215       assert_equal recipient.id, jsm["to_user_id"]
 216       assert_equal recipient.display_name, jsm["to_display_name"]
 217       assert_equal msg.title, jsm["title"]
 218       assert_not_nil jsm["sent_on"]
 219       assert_equal !msg.from_user_visible, jsm["deleted"]
 220       assert_not jsm.key?("message_read")
 221       assert_equal "markdown", jsm["body_format"]
 222       assert_equal msg.body, jsm["body"]
 223     end
 224
 225     def test_show_message_to_self_read
 226       user = create(:user)
 227       message = create(:message, :sender => user, :recipient => user)
 228       auth_header = bearer_authorization_header user
 229
 230       get api_message_path(message), :headers => auth_header
 231       assert_response :success
 232       assert_equal "application/xml", response.media_type
 233       assert_dom "message", :count => 1 do
 234         assert_dom "> @message_read", "false"
 235       end
 236     end
 237
 238     def test_show_message_to_self_read_json
 239       user = create(:user)
 240       message = create(:message, :sender => user, :recipient => user)
 241       auth_header = bearer_authorization_header user
 242
 243       get api_message_path(message, :format => "json"), :headers => auth_header
 244       assert_response :success
 245       assert_equal "application/json", response.media_type
 246       js = ActiveSupport::JSON.decode(@response.body)
 247       jsm = js["message"]
 248       assert_not_nil jsm
 249       assert jsm.key?("message_read")
 250       assert_not jsm["message_read"]
 251     end
 252
 253     def test_update_status
 254       recipient = create(:user)
 255       sender = create(:user)
 256       user3 = create(:user)
 257
 258       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
 259       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
 260
 261       msg = create(:message, :unread, :sender => sender, :recipient => recipient)
 262
 263       # attempt to mark message as read by recipient, not authenticated
 264       put api_message_path(msg), :params => { :read_status => true }
 265       assert_response :unauthorized
 266
 267       # attempt to mark message as read by recipient, not allowed
 268       put api_message_path(msg), :params => { :read_status => true }, :headers => user3_auth
 269       assert_response :forbidden
 270
 271       # missing parameter
 272       put api_message_path(msg), :headers => recipient_auth
 273       assert_response :bad_request
 274
 275       # wrong type of parameter
 276       put api_message_path(msg),
 277           :params => { :read_status => "not a boolean" },
 278           :headers => recipient_auth
 279       assert_response :bad_request
 280
 281       # mark message as read by recipient
 282       put api_message_path(msg, :format => "json"),
 283           :params => { :read_status => true },
 284           :headers => recipient_auth
 285       assert_response :success
 286       assert_equal "application/json", response.media_type
 287       js = ActiveSupport::JSON.decode(@response.body)
 288       jsm = js["message"]
 289       assert_not_nil jsm
 290       assert_equal msg.id, jsm["id"]
 291       assert_equal sender.id, jsm["from_user_id"]
 292       assert_equal sender.display_name, jsm["from_display_name"]
 293       assert_equal recipient.id, jsm["to_user_id"]
 294       assert_equal recipient.display_name, jsm["to_display_name"]
 295       assert_equal msg.title, jsm["title"]
 296       assert_not_nil jsm["sent_on"]
 297       assert jsm["message_read"]
 298       assert_equal !msg.to_user_visible, jsm["deleted"]
 299       assert_equal "markdown", jsm["body_format"]
 300       assert_equal msg.body, jsm["body"]
 301
 302       # mark message as unread by recipient
 303       put api_message_path(msg, :format => "json"),
 304           :params => { :read_status => false },
 305           :headers => recipient_auth
 306       assert_response :success
 307       assert_equal "application/json", response.media_type
 308       js = ActiveSupport::JSON.decode(@response.body)
 309       jsm = js["message"]
 310       assert_not_nil jsm
 311       assert_equal msg.id, jsm["id"]
 312       assert_equal sender.id, jsm["from_user_id"]
 313       assert_equal sender.display_name, jsm["from_display_name"]
 314       assert_equal recipient.id, jsm["to_user_id"]
 315       assert_equal recipient.display_name, jsm["to_display_name"]
 316       assert_equal msg.title, jsm["title"]
 317       assert_not_nil jsm["sent_on"]
 318       assert_not jsm["message_read"]
 319       assert_equal !msg.to_user_visible, jsm["deleted"]
 320       assert_equal "markdown", jsm["body_format"]
 321       assert_equal msg.body, jsm["body"]
 322     end
 323
 324     def test_delete
 325       recipient = create(:user)
 326       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
 327
 328       sender = create(:user)
 329       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
 330
 331       user3 = create(:user)
 332       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
 333
 334       msg = create(:message, :read, :sender => sender, :recipient => recipient)
 335
 336       # attempt to delete message, not authenticated
 337       delete api_message_path(msg)
 338       assert_response :unauthorized
 339
 340       # attempt to delete message, by user3
 341       delete api_message_path(msg), :headers => user3_auth
 342       assert_response :forbidden
 343
 344       # delete message by recipient
 345       delete api_message_path(msg, :format => "json"), :headers => recipient_auth
 346       assert_response :success
 347       assert_equal "application/json", response.media_type
 348       js = ActiveSupport::JSON.decode(@response.body)
 349       jsm = js["message"]
 350       assert_not_nil jsm
 351       assert_equal msg.id, jsm["id"]
 352       assert_equal sender.id, jsm["from_user_id"]
 353       assert_equal sender.display_name, jsm["from_display_name"]
 354       assert_equal recipient.id, jsm["to_user_id"]
 355       assert_equal recipient.display_name, jsm["to_display_name"]
 356       assert_equal msg.title, jsm["title"]
 357       assert_not_nil jsm["sent_on"]
 358       assert_equal msg.message_read, jsm["message_read"]
 359       assert jsm["deleted"]
 360       assert_equal "markdown", jsm["body_format"]
 361       assert_equal msg.body, jsm["body"]
 362
 363       # delete message by sender
 364       delete api_message_path(msg, :format => "json"), :headers => sender_auth
 365       assert_response :success
 366       assert_equal "application/json", response.media_type
 367       js = ActiveSupport::JSON.decode(@response.body)
 368       jsm = js["message"]
 369       assert_not_nil jsm
 370       assert_equal msg.id, jsm["id"]
 371       assert_equal sender.id, jsm["from_user_id"]
 372       assert_equal sender.display_name, jsm["from_display_name"]
 373       assert_equal recipient.id, jsm["to_user_id"]
 374       assert_equal recipient.display_name, jsm["to_display_name"]
 375       assert_equal msg.title, jsm["title"]
 376       assert_not_nil jsm["sent_on"]
 377       assert jsm["deleted"]
 378       assert_not jsm.key?("message_read")
 379       assert_equal "markdown", jsm["body_format"]
 380       assert_equal msg.body, jsm["body"]
 381     end
 382   end
 383 end