Merge pull request #1938 from jguthrie100/fix_no_trace_description_error
[rails.git] / test / controllers / messages_controller_test.rb
1 require "test_helper"
2
3 class MessagesControllerTest < ActionController::TestCase
4   ##
5   # test all routes which lead to this controller
6   def test_routes
7     assert_routing(
8       { :path => "/messages/inbox", :method => :get },
9       { :controller => "messages", :action => "inbox" }
10     )
11     assert_routing(
12       { :path => "/messages/outbox", :method => :get },
13       { :controller => "messages", :action => "outbox" }
14     )
15     assert_routing(
16       { :path => "/message/new/username", :method => :get },
17       { :controller => "messages", :action => "new", :display_name => "username" }
18     )
19     assert_routing(
20       { :path => "/message/new/username", :method => :post },
21       { :controller => "messages", :action => "new", :display_name => "username" }
22     )
23     assert_routing(
24       { :path => "/messages/1", :method => :get },
25       { :controller => "messages", :action => "show", :id => "1" }
26     )
27     assert_routing(
28       { :path => "/message/mark/1", :method => :post },
29       { :controller => "messages", :action => "mark", :message_id => "1" }
30     )
31     assert_routing(
32       { :path => "/message/reply/1", :method => :get },
33       { :controller => "messages", :action => "reply", :message_id => "1" }
34     )
35     assert_routing(
36       { :path => "/message/reply/1", :method => :post },
37       { :controller => "messages", :action => "reply", :message_id => "1" }
38     )
39     assert_routing(
40       { :path => "/message/delete/1", :method => :post },
41       { :controller => "messages", :action => "destroy", :message_id => "1" }
42     )
43   end
44
45   ##
46   # test fetching new message page when not logged in
47   def test_new_no_login
48     # Check that the new message page requires us to login
49     user = create(:user)
50     get :new, :params => { :display_name => user.display_name }
51     assert_redirected_to login_path(:referer => new_message_path(:display_name => user.display_name))
52   end
53
54   ##
55   # test fetching new message page when logged in
56   def test_new_form
57     # Login as a normal user
58     user = create(:user)
59     recipient_user = create(:user)
60     session[:user] = user.id
61
62     # Check that the new message page loads
63     get :new, :params => { :display_name => recipient_user.display_name }
64     assert_response :success
65     assert_template "new"
66     assert_select "title", "Send message | OpenStreetMap"
67     assert_select "form[action='#{new_message_path(:display_name => recipient_user.display_name)}']", :count => 1 do
68       assert_select "input#message_title", :count => 1
69       assert_select "textarea#message_body", :count => 1
70       assert_select "input[type='submit'][value='Send']", :count => 1
71     end
72   end
73
74   ##
75   # test fetching new message page with body and title
76   def test_new_get_with_params
77     # Login as a normal user
78     user = create(:user)
79     recipient_user = create(:user)
80     session[:user] = user.id
81
82     # Check that we can't send a message from a GET request
83     assert_difference "ActionMailer::Base.deliveries.size", 0 do
84       assert_difference "Message.count", 0 do
85         get :new,
86             :params => { :display_name => recipient_user.display_name,
87                          :message => { :title => "Test Message", :body => "Test message body" } }
88       end
89     end
90     assert_response :success
91     assert_template "new"
92     assert_select "title", "Send message | OpenStreetMap"
93     assert_select "form[action='#{new_message_path(:display_name => recipient_user.display_name)}']", :count => 1 do
94       assert_select "input#message_title", :count => 1 do
95         assert_select "[value='Test Message']"
96       end
97       assert_select "textarea#message_body", :text => "Test message body", :count => 1
98       assert_select "input[type='submit'][value='Send']", :count => 1
99     end
100   end
101
102   ##
103   # test posting new message page with no body
104   def test_new_post_no_body
105     # Login as a normal user
106     user = create(:user)
107     recipient_user = create(:user)
108     session[:user] = user.id
109
110     # Check that the subject is preserved over errors
111     assert_difference "ActionMailer::Base.deliveries.size", 0 do
112       assert_difference "Message.count", 0 do
113         post :new,
114              :params => { :display_name => recipient_user.display_name,
115                           :message => { :title => "Test Message", :body => "" } }
116       end
117     end
118     assert_response :success
119     assert_template "new"
120     assert_select "title", "Send message | OpenStreetMap"
121     assert_select "form[action='#{new_message_path(:display_name => recipient_user.display_name)}']", :count => 1 do
122       assert_select "input#message_title", :count => 1 do
123         assert_select "[value='Test Message']"
124       end
125       assert_select "textarea#message_body", :text => "", :count => 1
126       assert_select "input[type='submit'][value='Send']", :count => 1
127     end
128   end
129
130   ##
131   # test posting new message page with no title
132   def test_new_post_no_title
133     # Login as a normal user
134     user = create(:user)
135     recipient_user = create(:user)
136     session[:user] = user.id
137
138     # Check that the body text is preserved over errors
139     assert_difference "ActionMailer::Base.deliveries.size", 0 do
140       assert_difference "Message.count", 0 do
141         post :new,
142              :params => { :display_name => recipient_user.display_name,
143                           :message => { :title => "", :body => "Test message body" } }
144       end
145     end
146     assert_response :success
147     assert_template "new"
148     assert_select "title", "Send message | OpenStreetMap"
149     assert_select "form[action='#{new_message_path(:display_name => recipient_user.display_name)}']", :count => 1 do
150       assert_select "input#message_title", :count => 1 do
151         assert_select "[value='']"
152       end
153       assert_select "textarea#message_body", :text => "Test message body", :count => 1
154       assert_select "input[type='submit'][value='Send']", :count => 1
155     end
156   end
157
158   ##
159   # test posting new message page sends message
160   def test_new_post_send
161     # Login as a normal user
162     user = create(:user)
163     recipient_user = create(:user)
164     session[:user] = user.id
165
166     # Check that sending a message works
167     assert_difference "ActionMailer::Base.deliveries.size", 1 do
168       assert_difference "Message.count", 1 do
169         post :new,
170              :params => { :display_name => recipient_user.display_name,
171                           :message => { :title => "Test Message", :body => "Test message body" } }
172       end
173     end
174     assert_redirected_to inbox_messages_path
175     assert_equal "Message sent", flash[:notice]
176     e = ActionMailer::Base.deliveries.first
177     assert_equal [recipient_user.email], e.to
178     assert_equal "[OpenStreetMap] Test Message", e.subject
179     assert_match /Test message body/, e.text_part.decoded
180     assert_match /Test message body/, e.html_part.decoded
181     assert_match %r{#{SERVER_URL}/messages/[0-9]+}, e.text_part.decoded
182     ActionMailer::Base.deliveries.clear
183     m = Message.last
184     assert_equal user.id, m.from_user_id
185     assert_equal recipient_user.id, m.to_user_id
186     assert_in_delta Time.now, m.sent_on, 2
187     assert_equal "Test Message", m.title
188     assert_equal "Test message body", m.body
189     assert_equal "markdown", m.body_format
190
191     # Asking to send a message with a bogus user name should fail
192     get :new, :params => { :display_name => "non_existent_user" }
193     assert_response :not_found
194     assert_template "user/no_such_user"
195     assert_select "h1", "The user non_existent_user does not exist"
196   end
197
198   ##
199   # test the new action message limit
200   def test_new_limit
201     # Login as a normal user
202     user = create(:user)
203     recipient_user = create(:user)
204     session[:user] = user.id
205
206     # Check that sending a message fails when the message limit is hit
207     assert_no_difference "ActionMailer::Base.deliveries.size" do
208       assert_no_difference "Message.count" do
209         with_message_limit(0) do
210           post :new,
211                :params => { :display_name => recipient_user.display_name,
212                             :message => { :title => "Test Message", :body => "Test message body" } }
213           assert_response :success
214           assert_template "new"
215           assert_select ".error", /wait a while/
216         end
217       end
218     end
219   end
220
221   ##
222   # test the reply action
223   def test_reply
224     user = create(:user)
225     recipient_user = create(:user)
226     other_user = create(:user)
227     unread_message = create(:message, :unread, :sender => user, :recipient => recipient_user)
228
229     # Check that the message reply page requires us to login
230     get :reply, :params => { :message_id => unread_message.id }
231     assert_redirected_to login_path(:referer => reply_message_path(:message_id => unread_message.id))
232
233     # Login as the wrong user
234     session[:user] = other_user.id
235
236     # Check that we can't reply to somebody else's message
237     get :reply, :params => { :message_id => unread_message.id }
238     assert_redirected_to login_path(:referer => reply_message_path(:message_id => unread_message.id))
239     assert_equal "You are logged in as `#{other_user.display_name}' but the message you have asked to reply to was not sent to that user. Please login as the correct user in order to reply.", flash[:notice]
240
241     # Login as the right user
242     session[:user] = recipient_user.id
243
244     # Check that the message reply page loads
245     get :reply, :params => { :message_id => unread_message.id }
246     assert_response :success
247     assert_template "new"
248     assert_select "title", "Re: #{unread_message.title} | OpenStreetMap"
249     assert_select "form[action='#{new_message_path(:display_name => user.display_name)}']", :count => 1 do
250       assert_select "input#message_title[value='Re: #{unread_message.title}']", :count => 1
251       assert_select "textarea#message_body", :count => 1
252       assert_select "input[type='submit'][value='Send']", :count => 1
253     end
254     assert_equal true, Message.find(unread_message.id).message_read
255
256     # Asking to reply to a message with no ID should fail
257     assert_raise ActionController::UrlGenerationError do
258       get :reply
259     end
260
261     # Asking to reply to a message with a bogus ID should fail
262     get :reply, :params => { :message_id => 99999 }
263     assert_response :not_found
264     assert_template "no_such_message"
265   end
266
267   ##
268   # test the show action
269   def test_show
270     user = create(:user)
271     recipient_user = create(:user)
272     other_user = create(:user)
273     unread_message = create(:message, :unread, :sender => user, :recipient => recipient_user)
274
275     # Check that the show message page requires us to login
276     get :show, :params => { :id => unread_message.id }
277     assert_redirected_to login_path(:referer => message_path(:id => unread_message.id))
278
279     # Login as the wrong user
280     session[:user] = other_user.id
281
282     # Check that we can't read the message
283     get :show, :params => { :id => unread_message.id }
284     assert_redirected_to login_path(:referer => message_path(:id => unread_message.id))
285     assert_equal "You are logged in as `#{other_user.display_name}' but the message you have asked to read was not sent by or to that user. Please login as the correct user in order to read it.", flash[:notice]
286
287     # Login as the message sender
288     session[:user] = user.id
289
290     # Check that the message sender can read the message
291     get :show, :params => { :id => unread_message.id }
292     assert_response :success
293     assert_template "show"
294     assert_equal false, Message.find(unread_message.id).message_read
295
296     # Login as the message recipient
297     session[:user] = recipient_user.id
298
299     # Check that the message recipient can read the message
300     get :show, :params => { :id => unread_message.id }
301     assert_response :success
302     assert_template "show"
303     assert_equal true, Message.find(unread_message.id).message_read
304
305     # Asking to read a message with no ID should fail
306     assert_raise ActionController::UrlGenerationError do
307       get :show
308     end
309
310     # Asking to read a message with a bogus ID should fail
311     get :show, :params => { :id => 99999 }
312     assert_response :not_found
313     assert_template "no_such_message"
314   end
315
316   ##
317   # test the inbox action
318   def test_inbox
319     user = create(:user)
320     read_message = create(:message, :read, :recipient => user)
321     # Check that the inbox page requires us to login
322     get :inbox
323     assert_redirected_to login_path(:referer => inbox_messages_path)
324
325     # Login
326     session[:user] = user.id
327
328     # Check that we can view our inbox when logged in
329     get :inbox
330     assert_response :success
331     assert_template "inbox"
332     assert_select "table.messages", :count => 1 do
333       assert_select "tr", :count => 2
334       assert_select "tr#inbox-#{read_message.id}.inbox-row", :count => 1
335     end
336   end
337
338   ##
339   # test the outbox action
340   def test_outbox
341     user = create(:user)
342     create(:message, :sender => user)
343
344     # Check that the outbox page requires us to login
345     get :outbox
346     assert_redirected_to login_path(:referer => outbox_messages_path)
347
348     # Login
349     session[:user] = user.id
350
351     # Check that we can view our outbox when logged in
352     get :outbox
353     assert_response :success
354     assert_template "outbox"
355     assert_select "table.messages", :count => 1 do
356       assert_select "tr", :count => 2
357       assert_select "tr.inbox-row", :count => 1
358     end
359   end
360
361   ##
362   # test the mark action
363   def test_mark
364     user = create(:user)
365     recipient_user = create(:user)
366     other_user = create(:user)
367     unread_message = create(:message, :unread, :sender => user, :recipient => recipient_user)
368
369     # Check that the marking a message requires us to login
370     post :mark, :params => { :message_id => unread_message.id }
371     assert_response :forbidden
372
373     # Login as a user with no messages
374     session[:user] = other_user.id
375
376     # Check that marking a message we didn't send or receive fails
377     post :mark, :params => { :message_id => unread_message.id }
378     assert_response :not_found
379     assert_template "no_such_message"
380
381     # Login as the message recipient_user
382     session[:user] = recipient_user.id
383
384     # Check that the marking a message read works
385     post :mark, :params => { :message_id => unread_message.id, :mark => "read" }
386     assert_redirected_to inbox_messages_path
387     assert_equal true, Message.find(unread_message.id).message_read
388
389     # Check that the marking a message unread works
390     post :mark, :params => { :message_id => unread_message.id, :mark => "unread" }
391     assert_redirected_to inbox_messages_path
392     assert_equal false, Message.find(unread_message.id).message_read
393
394     # Check that the marking a message read via XHR works
395     post :mark, :xhr => true, :params => { :message_id => unread_message.id, :mark => "read" }
396     assert_response :success
397     assert_template "mark"
398     assert_equal true, Message.find(unread_message.id).message_read
399
400     # Check that the marking a message unread via XHR works
401     post :mark, :xhr => true, :params => { :message_id => unread_message.id, :mark => "unread" }
402     assert_response :success
403     assert_template "mark"
404     assert_equal false, Message.find(unread_message.id).message_read
405
406     # Asking to mark a message with no ID should fail
407     assert_raise ActionController::UrlGenerationError do
408       post :mark
409     end
410
411     # Asking to mark a message with a bogus ID should fail
412     post :mark, :params => { :message_id => 99999 }
413     assert_response :not_found
414     assert_template "no_such_message"
415   end
416
417   ##
418   # test the destroy action
419   def test_destroy
420     user = create(:user)
421     second_user = create(:user)
422     other_user = create(:user)
423     read_message = create(:message, :read, :recipient => user, :sender => second_user)
424     sent_message = create(:message, :unread, :recipient => second_user, :sender => user)
425
426     # Check that destroying a message requires us to login
427     post :destroy, :params => { :message_id => read_message.id }
428     assert_response :forbidden
429
430     # Login as a user with no messages
431     session[:user] = other_user.id
432
433     # Check that destroying a message we didn't send or receive fails
434     post :destroy, :params => { :message_id => read_message.id }
435     assert_response :not_found
436     assert_template "no_such_message"
437
438     # Login as the message recipient_user
439     session[:user] = user.id
440
441     # Check that the destroy a received message works
442     post :destroy, :params => { :message_id => read_message.id }
443     assert_redirected_to inbox_messages_path
444     assert_equal "Message deleted", flash[:notice]
445     m = Message.find(read_message.id)
446     assert_equal true, m.from_user_visible
447     assert_equal false, m.to_user_visible
448
449     # Check that the destroying a sent message works
450     post :destroy, :params => { :message_id => sent_message.id, :referer => outbox_messages_path }
451     assert_redirected_to outbox_messages_path
452     assert_equal "Message deleted", flash[:notice]
453     m = Message.find(sent_message.id)
454     assert_equal false, m.from_user_visible
455     assert_equal true, m.to_user_visible
456
457     # Asking to destroy a message with no ID should fail
458     assert_raise ActionController::UrlGenerationError do
459       post :destroy
460     end
461
462     # Asking to destroy a message with a bogus ID should fail
463     post :destroy, :params => { :message_id => 99999 }
464     assert_response :not_found
465     assert_template "no_such_message"
466   end
467
468   private
469
470   def with_message_limit(value)
471     max_messages_per_hour = Object.send("remove_const", "MAX_MESSAGES_PER_HOUR")
472     Object.const_set("MAX_MESSAGES_PER_HOUR", value)
473
474     yield
475
476     Object.send("remove_const", "MAX_MESSAGES_PER_HOUR")
477     Object.const_set("MAX_MESSAGES_PER_HOUR", max_messages_per_hour)
478   end
479 end