test/controllers/api/messages_controller_test.rb

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