]> git.openstreetmap.org Git - rails.git/blob - test/controllers/api/messages_controller_test.rb
Remove "User's Diary" from diary entry og:title
[rails.git] / 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/inbox", :method => :get },
10         { :controller => "api/messages", :action => "inbox" }
11       )
12       assert_routing(
13         { :path => "/api/0.6/user/messages/inbox.xml", :method => :get },
14         { :controller => "api/messages", :action => "inbox", :format => "xml" }
15       )
16       assert_routing(
17         { :path => "/api/0.6/user/messages/inbox.json", :method => :get },
18         { :controller => "api/messages", :action => "inbox", :format => "json" }
19       )
20       assert_routing(
21         { :path => "/api/0.6/user/messages/outbox", :method => :get },
22         { :controller => "api/messages", :action => "outbox" }
23       )
24       assert_routing(
25         { :path => "/api/0.6/user/messages/outbox.xml", :method => :get },
26         { :controller => "api/messages", :action => "outbox", :format => "xml" }
27       )
28       assert_routing(
29         { :path => "/api/0.6/user/messages/outbox.json", :method => :get },
30         { :controller => "api/messages", :action => "outbox", :format => "json" }
31       )
32       assert_routing(
33         { :path => "/api/0.6/user/messages/1", :method => :get },
34         { :controller => "api/messages", :action => "show", :id => "1" }
35       )
36       assert_routing(
37         { :path => "/api/0.6/user/messages/1.xml", :method => :get },
38         { :controller => "api/messages", :action => "show", :id => "1", :format => "xml" }
39       )
40       assert_routing(
41         { :path => "/api/0.6/user/messages/1.json", :method => :get },
42         { :controller => "api/messages", :action => "show", :id => "1", :format => "json" }
43       )
44       assert_routing(
45         { :path => "/api/0.6/user/messages", :method => :post },
46         { :controller => "api/messages", :action => "create" }
47       )
48       assert_routing(
49         { :path => "/api/0.6/user/messages/1", :method => :post },
50         { :controller => "api/messages", :action => "update", :id => "1" }
51       )
52       assert_routing(
53         { :path => "/api/0.6/user/messages/1", :method => :delete },
54         { :controller => "api/messages", :action => "destroy", :id => "1" }
55       )
56     end
57
58     def test_create_success
59       recipient = create(:user)
60       sender = create(:user)
61
62       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
63
64       msg = build(:message)
65
66       assert_difference "Message.count", 1 do
67         assert_difference "ActionMailer::Base.deliveries.size", 1 do
68           perform_enqueued_jobs do
69             post api_messages_path,
70                  :params => { :title => msg.title,
71                               :recipient_id => recipient.id,
72                               :body => msg.body,
73                               :format => "json" },
74                  :headers => sender_auth
75             assert_response :success
76           end
77         end
78       end
79
80       assert_equal "application/json", response.media_type
81       js = ActiveSupport::JSON.decode(@response.body)
82       jsm = js["message"]
83       assert_not_nil jsm
84       assert_not_nil jsm["id"]
85       assert_equal sender.id, jsm["from_user_id"]
86       assert_equal sender.display_name, jsm["from_display_name"]
87       assert_equal recipient.id, jsm["to_user_id"]
88       assert_equal recipient.display_name, jsm["to_display_name"]
89       assert_equal msg.title, jsm["title"]
90       assert_not_nil jsm["sent_on"]
91       assert_equal !msg.from_user_visible, jsm["deleted"]
92       assert_not jsm.key?("message_read")
93       assert_equal "markdown", jsm["body_format"]
94       assert_equal msg.body, jsm["body"]
95     end
96
97     def test_create_fail
98       recipient = create(:user)
99
100       sender = create(:user)
101       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
102
103       assert_no_difference "Message.count" do
104         assert_no_difference "ActionMailer::Base.deliveries.size" do
105           perform_enqueued_jobs do
106             post api_messages_path,
107                  :params => { :title => "Title",
108                               :recipient_id => recipient.id,
109                               :body => "body" }
110           end
111         end
112       end
113       assert_response :unauthorized
114
115       assert_no_difference "Message.count" do
116         assert_no_difference "ActionMailer::Base.deliveries.size" do
117           perform_enqueued_jobs do
118             post api_messages_path,
119                  :params => { :recipient_id => recipient.id,
120                               :body => "body" },
121                  :headers => sender_auth
122           end
123         end
124       end
125       assert_response :bad_request
126
127       assert_no_difference "Message.count" do
128         assert_no_difference "ActionMailer::Base.deliveries.size" do
129           perform_enqueued_jobs do
130             post api_messages_path,
131                  :params => { :title => "Title",
132                               :body => "body" },
133                  :headers => sender_auth
134           end
135         end
136       end
137       assert_response :bad_request
138
139       assert_no_difference "Message.count" do
140         assert_no_difference "ActionMailer::Base.deliveries.size" do
141           perform_enqueued_jobs do
142             post api_messages_path,
143                  :params => { :title => "Title",
144                               :recipient_id => recipient.id },
145                  :headers => sender_auth
146           end
147         end
148       end
149       assert_response :bad_request
150     end
151
152     def test_show
153       recipient = create(:user)
154       sender = create(:user)
155       user3 = create(:user)
156
157       sender_auth = bearer_authorization_header(sender, :scopes => %w[consume_messages])
158       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
159       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
160
161       msg = create(:message, :unread, :sender => sender, :recipient => recipient)
162
163       # fail if not authorized
164       get api_message_path(:id => msg.id)
165       assert_response :unauthorized
166
167       # only recipient and sender can read the message
168       get api_message_path(:id => msg.id), :headers => user3_auth
169       assert_response :forbidden
170
171       # message does not exist
172       get api_message_path(:id => 99999), :headers => user3_auth
173       assert_response :not_found
174
175       # verify xml output
176       get api_message_path(:id => msg.id), :headers => recipient_auth
177       assert_equal "application/xml", response.media_type
178       assert_select "message", :count => 1 do
179         assert_select "[id='#{msg.id}']"
180         assert_select "[from_user_id='#{sender.id}']"
181         assert_select "[from_display_name='#{sender.display_name}']"
182         assert_select "[to_user_id='#{recipient.id}']"
183         assert_select "[to_display_name='#{recipient.display_name}']"
184         assert_select "[sent_on]"
185         assert_select "[deleted='#{!msg.to_user_visible}']"
186         assert_select "[message_read='#{msg.message_read}']"
187         assert_select "[body_format='markdown']"
188         assert_select "title", msg.title
189         assert_select "body", msg.body
190       end
191
192       # verify json output
193       get api_message_path(:id => msg.id, :format => "json"), :headers => recipient_auth
194       assert_equal "application/json", response.media_type
195       js = ActiveSupport::JSON.decode(@response.body)
196       jsm = js["message"]
197       assert_not_nil jsm
198       assert_equal msg.id, jsm["id"]
199       assert_equal sender.id, jsm["from_user_id"]
200       assert_equal sender.display_name, jsm["from_display_name"]
201       assert_equal recipient.id, jsm["to_user_id"]
202       assert_equal recipient.display_name, jsm["to_display_name"]
203       assert_equal msg.title, jsm["title"]
204       assert_not_nil jsm["sent_on"]
205       assert_equal msg.message_read, jsm["message_read"]
206       assert_equal !msg.to_user_visible, jsm["deleted"]
207       assert_equal "markdown", jsm["body_format"]
208       assert_equal msg.body, jsm["body"]
209
210       get api_message_path(:id => msg.id), :headers => sender_auth
211       assert_equal "application/xml", response.media_type
212       assert_select "message", :count => 1 do
213         assert_select "[id='#{msg.id}']"
214         assert_select "[from_user_id='#{sender.id}']"
215         assert_select "[from_display_name='#{sender.display_name}']"
216         assert_select "[to_user_id='#{recipient.id}']"
217         assert_select "[to_display_name='#{recipient.display_name}']"
218         assert_select "[sent_on]"
219         assert_select "[deleted='#{!msg.from_user_visible}']"
220         assert_select "[message_read='#{msg.message_read}']", 0
221         assert_select "[body_format='markdown']"
222         assert_select "title", msg.title
223         assert_select "body", msg.body
224       end
225
226       # verify json output
227       get api_message_path(:id => msg.id, :format => "json"), :headers => sender_auth
228       assert_equal "application/json", response.media_type
229       js = ActiveSupport::JSON.decode(@response.body)
230       jsm = js["message"]
231       assert_not_nil jsm
232       assert_equal msg.id, jsm["id"]
233       assert_equal sender.id, jsm["from_user_id"]
234       assert_equal sender.display_name, jsm["from_display_name"]
235       assert_equal recipient.id, jsm["to_user_id"]
236       assert_equal recipient.display_name, jsm["to_display_name"]
237       assert_equal msg.title, jsm["title"]
238       assert_not_nil jsm["sent_on"]
239       assert_equal !msg.from_user_visible, jsm["deleted"]
240       assert_not jsm.key?("message_read")
241       assert_equal "markdown", jsm["body_format"]
242       assert_equal msg.body, jsm["body"]
243     end
244
245     def test_update_status
246       recipient = create(:user)
247       sender = create(:user)
248       user3 = create(:user)
249
250       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
251       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
252
253       msg = create(:message, :unread, :sender => sender, :recipient => recipient)
254
255       # attempt to mark message as read by recipient, not authenticated
256       post api_message_path(:id => msg.id), :params => { :read_status => true }
257       assert_response :unauthorized
258
259       # attempt to mark message as read by recipient, not allowed
260       post api_message_path(:id => msg.id), :params => { :read_status => true }, :headers => user3_auth
261       assert_response :forbidden
262
263       # missing parameter
264       post api_message_path(:id => msg.id), :headers => recipient_auth
265       assert_response :bad_request
266
267       # wrong type of parameter
268       post api_message_path(:id => msg.id),
269            :params => { :read_status => "not a boolean" },
270            :headers => recipient_auth
271       assert_response :bad_request
272
273       # mark message as read by recipient
274       post api_message_path(:id => msg.id, :format => "json"),
275            :params => { :read_status => true },
276            :headers => recipient_auth
277       assert_response :success
278       assert_equal "application/json", response.media_type
279       js = ActiveSupport::JSON.decode(@response.body)
280       jsm = js["message"]
281       assert_not_nil jsm
282       assert_equal msg.id, jsm["id"]
283       assert_equal sender.id, jsm["from_user_id"]
284       assert_equal sender.display_name, jsm["from_display_name"]
285       assert_equal recipient.id, jsm["to_user_id"]
286       assert_equal recipient.display_name, jsm["to_display_name"]
287       assert_equal msg.title, jsm["title"]
288       assert_not_nil jsm["sent_on"]
289       assert jsm["message_read"]
290       assert_equal !msg.to_user_visible, jsm["deleted"]
291       assert_equal "markdown", jsm["body_format"]
292       assert_equal msg.body, jsm["body"]
293
294       # mark message as unread by recipient
295       post api_message_path(:id => msg.id, :format => "json"),
296            :params => { :read_status => false },
297            :headers => recipient_auth
298       assert_response :success
299       assert_equal "application/json", response.media_type
300       js = ActiveSupport::JSON.decode(@response.body)
301       jsm = js["message"]
302       assert_not_nil jsm
303       assert_equal msg.id, jsm["id"]
304       assert_equal sender.id, jsm["from_user_id"]
305       assert_equal sender.display_name, jsm["from_display_name"]
306       assert_equal recipient.id, jsm["to_user_id"]
307       assert_equal recipient.display_name, jsm["to_display_name"]
308       assert_equal msg.title, jsm["title"]
309       assert_not_nil jsm["sent_on"]
310       assert_not jsm["message_read"]
311       assert_equal !msg.to_user_visible, jsm["deleted"]
312       assert_equal "markdown", jsm["body_format"]
313       assert_equal msg.body, jsm["body"]
314     end
315
316     def test_delete
317       recipient = create(:user)
318       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
319
320       sender = create(:user)
321       sender_auth = bearer_authorization_header(sender, :scopes => %w[send_messages consume_messages])
322
323       user3 = create(:user)
324       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
325
326       msg = create(:message, :read, :sender => sender, :recipient => recipient)
327
328       # attempt to delete message, not authenticated
329       delete api_message_path(:id => msg.id)
330       assert_response :unauthorized
331
332       # attempt to delete message, by user3
333       delete api_message_path(:id => msg.id), :headers => user3_auth
334       assert_response :forbidden
335
336       # delete message by recipient
337       delete api_message_path(:id => msg.id, :format => "json"), :headers => recipient_auth
338       assert_response :success
339       assert_equal "application/json", response.media_type
340       js = ActiveSupport::JSON.decode(@response.body)
341       jsm = js["message"]
342       assert_not_nil jsm
343       assert_equal msg.id, jsm["id"]
344       assert_equal sender.id, jsm["from_user_id"]
345       assert_equal sender.display_name, jsm["from_display_name"]
346       assert_equal recipient.id, jsm["to_user_id"]
347       assert_equal recipient.display_name, jsm["to_display_name"]
348       assert_equal msg.title, jsm["title"]
349       assert_not_nil jsm["sent_on"]
350       assert_equal msg.message_read, jsm["message_read"]
351       assert jsm["deleted"]
352       assert_equal "markdown", jsm["body_format"]
353       assert_equal msg.body, jsm["body"]
354
355       # delete message by sender
356       delete api_message_path(:id => msg.id, :format => "json"), :headers => sender_auth
357       assert_response :success
358       assert_equal "application/json", response.media_type
359       js = ActiveSupport::JSON.decode(@response.body)
360       jsm = js["message"]
361       assert_not_nil jsm
362       assert_equal msg.id, jsm["id"]
363       assert_equal sender.id, jsm["from_user_id"]
364       assert_equal sender.display_name, jsm["from_display_name"]
365       assert_equal recipient.id, jsm["to_user_id"]
366       assert_equal recipient.display_name, jsm["to_display_name"]
367       assert_equal msg.title, jsm["title"]
368       assert_not_nil jsm["sent_on"]
369       assert jsm["deleted"]
370       assert_not jsm.key?("message_read")
371       assert_equal "markdown", jsm["body_format"]
372       assert_equal msg.body, jsm["body"]
373     end
374
375     def test_list_messages
376       user1 = create(:user)
377       user1_auth = bearer_authorization_header(user1, :scopes => %w[send_messages consume_messages])
378
379       user2 = create(:user)
380       user2_auth = bearer_authorization_header(user2, :scopes => %w[send_messages consume_messages])
381
382       user3 = create(:user)
383       user3_auth = bearer_authorization_header(user3, :scopes => %w[send_messages consume_messages])
384
385       # create some messages between users
386       # user | inbox | outbox
387       #   1  |   0   |   3
388       #   2  |   2   |   1
389       #   3  |   2   |   0
390       create(:message, :unread, :sender => user1, :recipient => user2)
391       create(:message, :unread, :sender => user1, :recipient => user2)
392       create(:message, :unread, :sender => user1, :recipient => user3)
393       create(:message, :unread, :sender => user2, :recipient => user3)
394
395       # only authorized users
396       get inbox_api_messages_path
397       assert_response :unauthorized
398       get outbox_api_messages_path
399       assert_response :unauthorized
400
401       # no messages in user1.inbox
402       get inbox_api_messages_path, :headers => user1_auth
403       assert_response :success
404       assert_equal "application/xml", response.media_type
405       assert_select "message", :count => 0
406
407       # 3 messages in user1.outbox
408       get outbox_api_messages_path, :headers => user1_auth
409       assert_response :success
410       assert_equal "application/xml", response.media_type
411       assert_select "message", :count => 3 do
412         assert_select "[from_user_id='#{user1.id}']"
413         assert_select "[from_display_name='#{user1.display_name}']"
414         assert_select "[to_user_id]"
415         assert_select "[to_display_name]"
416         assert_select "[sent_on]"
417         assert_select "[message_read]", 0
418         assert_select "[deleted='false']"
419         assert_select "[body_format]"
420         assert_select "body", false
421         assert_select "title"
422       end
423
424       # 2 messages in user2.inbox
425       get inbox_api_messages_path, :headers => user2_auth
426       assert_response :success
427       assert_equal "application/xml", response.media_type
428       assert_select "message", :count => 2 do
429         assert_select "[from_user_id]"
430         assert_select "[from_display_name]"
431         assert_select "[to_user_id='#{user2.id}']"
432         assert_select "[to_display_name='#{user2.display_name}']"
433         assert_select "[sent_on]"
434         assert_select "[message_read='false']"
435         assert_select "[deleted='false']"
436         assert_select "[body_format]"
437         assert_select "body", false
438         assert_select "title"
439       end
440
441       # 1 message in user2.outbox
442       get outbox_api_messages_path, :headers => user2_auth
443       assert_response :success
444       assert_equal "application/xml", response.media_type
445       assert_select "message", :count => 1 do
446         assert_select "[from_user_id='#{user2.id}']"
447         assert_select "[from_display_name='#{user2.display_name}']"
448         assert_select "[to_user_id]"
449         assert_select "[to_display_name]"
450         assert_select "[sent_on]"
451         assert_select "[deleted='false']"
452         assert_select "[message_read]", 0
453         assert_select "[body_format]"
454         assert_select "body", false
455         assert_select "title"
456       end
457
458       # 2 messages in user3.inbox
459       get inbox_api_messages_path, :headers => user3_auth
460       assert_response :success
461       assert_equal "application/xml", response.media_type
462       assert_select "message", :count => 2 do
463         assert_select "[from_user_id]"
464         assert_select "[from_display_name]"
465         assert_select "[to_user_id='#{user3.id}']"
466         assert_select "[to_display_name='#{user3.display_name}']"
467         assert_select "[sent_on]"
468         assert_select "[message_read='false']"
469         assert_select "[deleted='false']"
470         assert_select "[body_format]"
471         assert_select "body", false
472         assert_select "title"
473       end
474
475       # 0 messages in user3.outbox
476       get outbox_api_messages_path, :headers => user3_auth
477       assert_response :success
478       assert_equal "application/xml", response.media_type
479       assert_select "message", :count => 0
480     end
481
482     def test_paged_list_messages_asc
483       recipient = create(:user)
484       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
485
486       sender = create(:user)
487
488       create_list(:message, 100, :unread, :sender => sender, :recipient => recipient)
489
490       msgs_read = {}
491       params = { :order => "oldest", :limit => 20 }
492       10.times do
493         get inbox_api_messages_path(:format => "json"),
494             :params => params,
495             :headers => recipient_auth
496         assert_response :success
497         assert_equal "application/json", response.media_type
498         js = ActiveSupport::JSON.decode(@response.body)
499         jsm = js["messages"]
500         assert_operator jsm.count, :<=, 20
501
502         break if jsm.nil? || jsm.count.zero?
503
504         assert_operator(jsm[0]["id"], :>=, params[:from_id]) unless params[:from_id].nil?
505         # ensure ascending order
506         (0..jsm.count - 1).each do |i|
507           assert_operator(jsm[i]["id"], :<, jsm[i + 1]["id"]) unless i == jsm.count - 1
508           msgs_read[jsm[i]["id"]] = jsm[i]
509         end
510         params[:from_id] = jsm[jsm.count - 1]["id"]
511       end
512       assert_equal 100, msgs_read.count
513     end
514
515     def test_paged_list_messages_desc
516       recipient = create(:user)
517       recipient_auth = bearer_authorization_header(recipient, :scopes => %w[consume_messages])
518
519       sender = create(:user)
520
521       create_list(:message, 100, :unread, :sender => sender, :recipient => recipient)
522
523       real_max_id = -1
524       msgs_read = {}
525       params = { :order => "newest", :limit => 20 }
526       10.times do
527         get inbox_api_messages_path(:format => "json"),
528             :params => params,
529             :headers => recipient_auth
530         assert_response :success
531         assert_equal "application/json", response.media_type
532         js = ActiveSupport::JSON.decode(@response.body)
533         jsm = js["messages"]
534         assert_operator jsm.count, :<=, 20
535
536         break if jsm.nil? || jsm.count.zero?
537
538         if params[:from_id].nil?
539           real_max_id = jsm[0]["id"]
540         else
541           assert_operator jsm[0]["id"], :<=, params[:from_id]
542         end
543         # ensure descending order
544         (0..jsm.count - 1).each do |i|
545           assert_operator(jsm[i]["id"], :>, jsm[i + 1]["id"]) unless i == jsm.count - 1
546           msgs_read[jsm[i]["id"]] = jsm[i]
547         end
548         params[:from_id] = jsm[jsm.count - 1]["id"]
549       end
550       assert_equal 100, msgs_read.count
551       assert_not_equal(-1, real_max_id)
552
553       # invoke without min_id/max_id parameters, verify that we get the last batch
554       get inbox_api_messages_path(:format => "json"), :params => { :limit => 20 }, :headers => recipient_auth
555       assert_response :success
556       assert_equal "application/json", response.media_type
557       js = ActiveSupport::JSON.decode(@response.body)
558       jsm = js["messages"]
559       assert_not_nil jsm
560       assert_equal real_max_id, jsm[0]["id"]
561     end
562   end
563 end