##// END OF EJS Templates
jro_apps » redmine
RSS
support more character encoding in incoming emails (#15785)...
Toshi MARUYAMA -
r12199:803a0a030eb5
parent child
Show More
Side by Side Unified
Context file:
r12199:803a0a030eb5 Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,14
1 From: John Smith <JSmith@somenet.foo>
2 To: "redmine@somenet.foo" <redmine@somenet.foo>
3 Subject: This is a test
4 Content-Type: multipart/alternative;
5 boundary="_c20d9cfa-d16a-43a3-a7e5-71da7877ab23_"
6
7 --_c20d9cfa-d16a-43a3-a7e5-71da7877ab23_
8 Content-Type: text/plain; charset="ks_c_5601-1987"
9 Content-Transfer-Encoding: base64
10
11 sO24v73AtM+02S4=
12
13 --_c20d9cfa-d16a-43a3-a7e5-71da7877ab23_--
14
Show file before | Show file after | Hide comments
@@ -1,536 +1,540
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2013 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 class MailHandler < ActionMailer::Base
19 19 include ActionView::Helpers::SanitizeHelper
20 20 include Redmine::I18n
21 21
22 22 class UnauthorizedAction < StandardError; end
23 23 class MissingInformation < StandardError; end
24 24
25 25 attr_reader :email, :user
26 26
27 27 def self.receive(email, options={})
28 28 @@handler_options = options.dup
29 29
30 30 @@handler_options[:issue] ||= {}
31 31
32 32 if @@handler_options[:allow_override].is_a?(String)
33 33 @@handler_options[:allow_override] = @@handler_options[:allow_override].split(',').collect(&:strip)
34 34 end
35 35 @@handler_options[:allow_override] ||= []
36 36 # Project needs to be overridable if not specified
37 37 @@handler_options[:allow_override] << 'project' unless @@handler_options[:issue].has_key?(:project)
38 38 # Status overridable by default
39 39 @@handler_options[:allow_override] << 'status' unless @@handler_options[:issue].has_key?(:status)
40 40
41 41 @@handler_options[:no_account_notice] = (@@handler_options[:no_account_notice].to_s == '1')
42 42 @@handler_options[:no_notification] = (@@handler_options[:no_notification].to_s == '1')
43 43 @@handler_options[:no_permission_check] = (@@handler_options[:no_permission_check].to_s == '1')
44 44
45 45 email.force_encoding('ASCII-8BIT') if email.respond_to?(:force_encoding)
46 46 super(email)
47 47 end
48 48
49 49 # Extracts MailHandler options from environment variables
50 50 # Use when receiving emails with rake tasks
51 51 def self.extract_options_from_env(env)
52 52 options = {:issue => {}}
53 53 %w(project status tracker category priority).each do |option|
54 54 options[:issue][option.to_sym] = env[option] if env[option]
55 55 end
56 56 %w(allow_override unknown_user no_permission_check no_account_notice default_group).each do |option|
57 57 options[option.to_sym] = env[option] if env[option]
58 58 end
59 59 options
60 60 end
61 61
62 62 def logger
63 63 Rails.logger
64 64 end
65 65
66 66 cattr_accessor :ignored_emails_headers
67 67 @@ignored_emails_headers = {
68 68 'X-Auto-Response-Suppress' => 'oof',
69 69 'Auto-Submitted' => /^auto-/
70 70 }
71 71
72 72 # Processes incoming emails
73 73 # Returns the created object (eg. an issue, a message) or false
74 74 def receive(email)
75 75 @email = email
76 76 sender_email = email.from.to_a.first.to_s.strip
77 77 # Ignore emails received from the application emission address to avoid hell cycles
78 78 if sender_email.downcase == Setting.mail_from.to_s.strip.downcase
79 79 if logger
80 80 logger.info "MailHandler: ignoring email from Redmine emission address [#{sender_email}]"
81 81 end
82 82 return false
83 83 end
84 84 # Ignore auto generated emails
85 85 self.class.ignored_emails_headers.each do |key, ignored_value|
86 86 value = email.header[key]
87 87 if value
88 88 value = value.to_s.downcase
89 89 if (ignored_value.is_a?(Regexp) && value.match(ignored_value)) || value == ignored_value
90 90 if logger
91 91 logger.info "MailHandler: ignoring email with #{key}:#{value} header"
92 92 end
93 93 return false
94 94 end
95 95 end
96 96 end
97 97 @user = User.find_by_mail(sender_email) if sender_email.present?
98 98 if @user && !@user.active?
99 99 if logger
100 100 logger.info "MailHandler: ignoring email from non-active user [#{@user.login}]"
101 101 end
102 102 return false
103 103 end
104 104 if @user.nil?
105 105 # Email was submitted by an unknown user
106 106 case @@handler_options[:unknown_user]
107 107 when 'accept'
108 108 @user = User.anonymous
109 109 when 'create'
110 110 @user = create_user_from_email
111 111 if @user
112 112 if logger
113 113 logger.info "MailHandler: [#{@user.login}] account created"
114 114 end
115 115 add_user_to_group(@@handler_options[:default_group])
116 116 unless @@handler_options[:no_account_notice]
117 117 Mailer.account_information(@user, @user.password).deliver
118 118 end
119 119 else
120 120 if logger
121 121 logger.error "MailHandler: could not create account for [#{sender_email}]"
122 122 end
123 123 return false
124 124 end
125 125 else
126 126 # Default behaviour, emails from unknown users are ignored
127 127 if logger
128 128 logger.info "MailHandler: ignoring email from unknown user [#{sender_email}]"
129 129 end
130 130 return false
131 131 end
132 132 end
133 133 User.current = @user
134 134 dispatch
135 135 end
136 136
137 137 private
138 138
139 139 MESSAGE_ID_RE = %r{^<?redmine\.([a-z0-9_]+)\-(\d+)\.\d+(\.[a-f0-9]+)?@}
140 140 ISSUE_REPLY_SUBJECT_RE = %r{\[[^\]]*#(\d+)\]}
141 141 MESSAGE_REPLY_SUBJECT_RE = %r{\[[^\]]*msg(\d+)\]}
142 142
143 143 def dispatch
144 144 headers = [email.in_reply_to, email.references].flatten.compact
145 145 subject = email.subject.to_s
146 146 if headers.detect {|h| h.to_s =~ MESSAGE_ID_RE}
147 147 klass, object_id = $1, $2.to_i
148 148 method_name = "receive_#{klass}_reply"
149 149 if self.class.private_instance_methods.collect(&:to_s).include?(method_name)
150 150 send method_name, object_id
151 151 else
152 152 # ignoring it
153 153 end
154 154 elsif m = subject.match(ISSUE_REPLY_SUBJECT_RE)
155 155 receive_issue_reply(m[1].to_i)
156 156 elsif m = subject.match(MESSAGE_REPLY_SUBJECT_RE)
157 157 receive_message_reply(m[1].to_i)
158 158 else
159 159 dispatch_to_default
160 160 end
161 161 rescue ActiveRecord::RecordInvalid => e
162 162 # TODO: send a email to the user
163 163 logger.error e.message if logger
164 164 false
165 165 rescue MissingInformation => e
166 166 logger.error "MailHandler: missing information from #{user}: #{e.message}" if logger
167 167 false
168 168 rescue UnauthorizedAction => e
169 169 logger.error "MailHandler: unauthorized attempt from #{user}" if logger
170 170 false
171 171 end
172 172
173 173 def dispatch_to_default
174 174 receive_issue
175 175 end
176 176
177 177 # Creates a new issue
178 178 def receive_issue
179 179 project = target_project
180 180 # check permission
181 181 unless @@handler_options[:no_permission_check]
182 182 raise UnauthorizedAction unless user.allowed_to?(:add_issues, project)
183 183 end
184 184
185 185 issue = Issue.new(:author => user, :project => project)
186 186 issue.safe_attributes = issue_attributes_from_keywords(issue)
187 187 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
188 188 issue.subject = cleaned_up_subject
189 189 if issue.subject.blank?
190 190 issue.subject = '(no subject)'
191 191 end
192 192 issue.description = cleaned_up_text_body
193 193
194 194 # add To and Cc as watchers before saving so the watchers can reply to Redmine
195 195 add_watchers(issue)
196 196 issue.save!
197 197 add_attachments(issue)
198 198 logger.info "MailHandler: issue ##{issue.id} created by #{user}" if logger
199 199 issue
200 200 end
201 201
202 202 # Adds a note to an existing issue
203 203 def receive_issue_reply(issue_id, from_journal=nil)
204 204 issue = Issue.find_by_id(issue_id)
205 205 return unless issue
206 206 # check permission
207 207 unless @@handler_options[:no_permission_check]
208 208 unless user.allowed_to?(:add_issue_notes, issue.project) ||
209 209 user.allowed_to?(:edit_issues, issue.project)
210 210 raise UnauthorizedAction
211 211 end
212 212 end
213 213
214 214 # ignore CLI-supplied defaults for new issues
215 215 @@handler_options[:issue].clear
216 216
217 217 journal = issue.init_journal(user)
218 218 if from_journal && from_journal.private_notes?
219 219 # If the received email was a reply to a private note, make the added note private
220 220 issue.private_notes = true
221 221 end
222 222 issue.safe_attributes = issue_attributes_from_keywords(issue)
223 223 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
224 224 journal.notes = cleaned_up_text_body
225 225 add_attachments(issue)
226 226 issue.save!
227 227 if logger
228 228 logger.info "MailHandler: issue ##{issue.id} updated by #{user}"
229 229 end
230 230 journal
231 231 end
232 232
233 233 # Reply will be added to the issue
234 234 def receive_journal_reply(journal_id)
235 235 journal = Journal.find_by_id(journal_id)
236 236 if journal && journal.journalized_type == 'Issue'
237 237 receive_issue_reply(journal.journalized_id, journal)
238 238 end
239 239 end
240 240
241 241 # Receives a reply to a forum message
242 242 def receive_message_reply(message_id)
243 243 message = Message.find_by_id(message_id)
244 244 if message
245 245 message = message.root
246 246
247 247 unless @@handler_options[:no_permission_check]
248 248 raise UnauthorizedAction unless user.allowed_to?(:add_messages, message.project)
249 249 end
250 250
251 251 if !message.locked?
252 252 reply = Message.new(:subject => cleaned_up_subject.gsub(%r{^.*msg\d+\]}, '').strip,
253 253 :content => cleaned_up_text_body)
254 254 reply.author = user
255 255 reply.board = message.board
256 256 message.children << reply
257 257 add_attachments(reply)
258 258 reply
259 259 else
260 260 if logger
261 261 logger.info "MailHandler: ignoring reply from [#{sender_email}] to a locked topic"
262 262 end
263 263 end
264 264 end
265 265 end
266 266
267 267 def add_attachments(obj)
268 268 if email.attachments && email.attachments.any?
269 269 email.attachments.each do |attachment|
270 270 next unless accept_attachment?(attachment)
271 271 obj.attachments << Attachment.create(:container => obj,
272 272 :file => attachment.decoded,
273 273 :filename => attachment.filename,
274 274 :author => user,
275 275 :content_type => attachment.mime_type)
276 276 end
277 277 end
278 278 end
279 279
280 280 # Returns false if the +attachment+ of the incoming email should be ignored
281 281 def accept_attachment?(attachment)
282 282 @excluded ||= Setting.mail_handler_excluded_filenames.to_s.split(',').map(&:strip).reject(&:blank?)
283 283 @excluded.each do |pattern|
284 284 regexp = %r{\A#{Regexp.escape(pattern).gsub("\\*", ".*")}\z}i
285 285 if attachment.filename.to_s =~ regexp
286 286 logger.info "MailHandler: ignoring attachment #{attachment.filename} matching #{pattern}"
287 287 return false
288 288 end
289 289 end
290 290 true
291 291 end
292 292
293 293 # Adds To and Cc as watchers of the given object if the sender has the
294 294 # appropriate permission
295 295 def add_watchers(obj)
296 296 if user.allowed_to?("add_#{obj.class.name.underscore}_watchers".to_sym, obj.project)
297 297 addresses = [email.to, email.cc].flatten.compact.uniq.collect {|a| a.strip.downcase}
298 298 unless addresses.empty?
299 299 watchers = User.active.where('LOWER(mail) IN (?)', addresses).all
300 300 watchers.each {|w| obj.add_watcher(w)}
301 301 end
302 302 end
303 303 end
304 304
305 305 def get_keyword(attr, options={})
306 306 @keywords ||= {}
307 307 if @keywords.has_key?(attr)
308 308 @keywords[attr]
309 309 else
310 310 @keywords[attr] = begin
311 311 if (options[:override] || @@handler_options[:allow_override].include?(attr.to_s)) &&
312 312 (v = extract_keyword!(plain_text_body, attr, options[:format]))
313 313 v
314 314 elsif !@@handler_options[:issue][attr].blank?
315 315 @@handler_options[:issue][attr]
316 316 end
317 317 end
318 318 end
319 319 end
320 320
321 321 # Destructively extracts the value for +attr+ in +text+
322 322 # Returns nil if no matching keyword found
323 323 def extract_keyword!(text, attr, format=nil)
324 324 keys = [attr.to_s.humanize]
325 325 if attr.is_a?(Symbol)
326 326 if user && user.language.present?
327 327 keys << l("field_#{attr}", :default => '', :locale => user.language)
328 328 end
329 329 if Setting.default_language.present?
330 330 keys << l("field_#{attr}", :default => '', :locale => Setting.default_language)
331 331 end
332 332 end
333 333 keys.reject! {|k| k.blank?}
334 334 keys.collect! {|k| Regexp.escape(k)}
335 335 format ||= '.+'
336 336 keyword = nil
337 337 regexp = /^(#{keys.join('|')})[ \t]*:[ \t]*(#{format})\s*$/i
338 338 if m = text.match(regexp)
339 339 keyword = m[2].strip
340 340 text.gsub!(regexp, '')
341 341 end
342 342 keyword
343 343 end
344 344
345 345 def target_project
346 346 # TODO: other ways to specify project:
347 347 # * parse the email To field
348 348 # * specific project (eg. Setting.mail_handler_target_project)
349 349 target = Project.find_by_identifier(get_keyword(:project))
350 350 if target.nil?
351 351 # Invalid project keyword, use the project specified as the default one
352 352 default_project = @@handler_options[:issue][:project]
353 353 if default_project.present?
354 354 target = Project.find_by_identifier(default_project)
355 355 end
356 356 end
357 357 raise MissingInformation.new('Unable to determine target project') if target.nil?
358 358 target
359 359 end
360 360
361 361 # Returns a Hash of issue attributes extracted from keywords in the email body
362 362 def issue_attributes_from_keywords(issue)
363 363 assigned_to = (k = get_keyword(:assigned_to, :override => true)) && find_assignee_from_keyword(k, issue)
364 364
365 365 attrs = {
366 366 'tracker_id' => (k = get_keyword(:tracker)) && issue.project.trackers.named(k).first.try(:id),
367 367 'status_id' => (k = get_keyword(:status)) && IssueStatus.named(k).first.try(:id),
368 368 'priority_id' => (k = get_keyword(:priority)) && IssuePriority.named(k).first.try(:id),
369 369 'category_id' => (k = get_keyword(:category)) && issue.project.issue_categories.named(k).first.try(:id),
370 370 'assigned_to_id' => assigned_to.try(:id),
371 371 'fixed_version_id' => (k = get_keyword(:fixed_version, :override => true)) &&
372 372 issue.project.shared_versions.named(k).first.try(:id),
373 373 'start_date' => get_keyword(:start_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
374 374 'due_date' => get_keyword(:due_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
375 375 'estimated_hours' => get_keyword(:estimated_hours, :override => true),
376 376 'done_ratio' => get_keyword(:done_ratio, :override => true, :format => '(\d|10)?0')
377 377 }.delete_if {|k, v| v.blank? }
378 378
379 379 if issue.new_record? && attrs['tracker_id'].nil?
380 380 attrs['tracker_id'] = issue.project.trackers.first.try(:id)
381 381 end
382 382
383 383 attrs
384 384 end
385 385
386 386 # Returns a Hash of issue custom field values extracted from keywords in the email body
387 387 def custom_field_values_from_keywords(customized)
388 388 customized.custom_field_values.inject({}) do |h, v|
389 389 if keyword = get_keyword(v.custom_field.name, :override => true)
390 390 h[v.custom_field.id.to_s] = v.custom_field.value_from_keyword(keyword, customized)
391 391 end
392 392 h
393 393 end
394 394 end
395 395
396 396 # Returns the text/plain part of the email
397 397 # If not found (eg. HTML-only email), returns the body with tags removed
398 398 def plain_text_body
399 399 return @plain_text_body unless @plain_text_body.nil?
400 400
401 401 parts = if (text_parts = email.all_parts.select {|p| p.mime_type == 'text/plain'}).present?
402 402 text_parts
403 403 elsif (html_parts = email.all_parts.select {|p| p.mime_type == 'text/html'}).present?
404 404 html_parts
405 405 else
406 406 [email]
407 407 end
408 408
409 409 parts.reject! do |part|
410 410 part.header[:content_disposition].try(:disposition_type) == 'attachment'
411 411 end
412 412
413 @plain_text_body = parts.map {|p| Redmine::CodesetUtil.to_utf8(p.body.decoded, p.charset)}.join("\r\n")
413 @plain_text_body = parts.map do |p|
414 body_charset = p.charset.respond_to?(:force_encoding) ?
415 Mail::RubyVer.pick_encoding(p.charset).to_s : p.charset
416 Redmine::CodesetUtil.to_utf8(p.body.decoded, body_charset)
417 end.join("\r\n")
414 418
415 419 # strip html tags and remove doctype directive
416 420 if parts.any? {|p| p.mime_type == 'text/html'}
417 421 @plain_text_body = strip_tags(@plain_text_body.strip)
418 422 @plain_text_body.sub! %r{^<!DOCTYPE .*$}, ''
419 423 end
420 424
421 425 @plain_text_body
422 426 end
423 427
424 428 def cleaned_up_text_body
425 429 cleanup_body(plain_text_body)
426 430 end
427 431
428 432 def cleaned_up_subject
429 433 subject = email.subject.to_s
430 434 subject.strip[0,255]
431 435 end
432 436
433 437 def self.full_sanitizer
434 438 @full_sanitizer ||= HTML::FullSanitizer.new
435 439 end
436 440
437 441 def self.assign_string_attribute_with_limit(object, attribute, value, limit=nil)
438 442 limit ||= object.class.columns_hash[attribute.to_s].limit || 255
439 443 value = value.to_s.slice(0, limit)
440 444 object.send("#{attribute}=", value)
441 445 end
442 446
443 447 # Returns a User from an email address and a full name
444 448 def self.new_user_from_attributes(email_address, fullname=nil)
445 449 user = User.new
446 450
447 451 # Truncating the email address would result in an invalid format
448 452 user.mail = email_address
449 453 assign_string_attribute_with_limit(user, 'login', email_address, User::LOGIN_LENGTH_LIMIT)
450 454
451 455 names = fullname.blank? ? email_address.gsub(/@.*$/, '').split('.') : fullname.split
452 456 assign_string_attribute_with_limit(user, 'firstname', names.shift, 30)
453 457 assign_string_attribute_with_limit(user, 'lastname', names.join(' '), 30)
454 458 user.lastname = '-' if user.lastname.blank?
455 459 user.language = Setting.default_language
456 460 user.generate_password = true
457 461 user.mail_notification = 'only_my_events'
458 462
459 463 unless user.valid?
460 464 user.login = "user#{Redmine::Utils.random_hex(6)}" unless user.errors[:login].blank?
461 465 user.firstname = "-" unless user.errors[:firstname].blank?
462 466 (puts user.errors[:lastname];user.lastname = "-") unless user.errors[:lastname].blank?
463 467 end
464 468
465 469 user
466 470 end
467 471
468 472 # Creates a User for the +email+ sender
469 473 # Returns the user or nil if it could not be created
470 474 def create_user_from_email
471 475 from = email.header['from'].to_s
472 476 addr, name = from, nil
473 477 if m = from.match(/^"?(.+?)"?\s+<(.+@.+)>$/)
474 478 addr, name = m[2], m[1]
475 479 end
476 480 if addr.present?
477 481 user = self.class.new_user_from_attributes(addr, name)
478 482 if @@handler_options[:no_notification]
479 483 user.mail_notification = 'none'
480 484 end
481 485 if user.save
482 486 user
483 487 else
484 488 logger.error "MailHandler: failed to create User: #{user.errors.full_messages}" if logger
485 489 nil
486 490 end
487 491 else
488 492 logger.error "MailHandler: failed to create User: no FROM address found" if logger
489 493 nil
490 494 end
491 495 end
492 496
493 497 # Adds the newly created user to default group
494 498 def add_user_to_group(default_group)
495 499 if default_group.present?
496 500 default_group.split(',').each do |group_name|
497 501 if group = Group.named(group_name).first
498 502 group.users << @user
499 503 elsif logger
500 504 logger.warn "MailHandler: could not add user to [#{group_name}], group not found"
501 505 end
502 506 end
503 507 end
504 508 end
505 509
506 510 # Removes the email body of text after the truncation configurations.
507 511 def cleanup_body(body)
508 512 delimiters = Setting.mail_handler_body_delimiters.to_s.split(/[\r\n]+/).reject(&:blank?).map {|s| Regexp.escape(s)}
509 513 unless delimiters.empty?
510 514 regex = Regexp.new("^[> ]*(#{ delimiters.join('|') })\s*[\r\n].*", Regexp::MULTILINE)
511 515 body = body.gsub(regex, '')
512 516 end
513 517 body.strip
514 518 end
515 519
516 520 def find_assignee_from_keyword(keyword, issue)
517 521 keyword = keyword.to_s.downcase
518 522 assignable = issue.assignable_users
519 523 assignee = nil
520 524 assignee ||= assignable.detect {|a|
521 525 a.mail.to_s.downcase == keyword ||
522 526 a.login.to_s.downcase == keyword
523 527 }
524 528 if assignee.nil? && keyword.match(/ /)
525 529 firstname, lastname = *(keyword.split) # "First Last Throwaway"
526 530 assignee ||= assignable.detect {|a|
527 531 a.is_a?(User) && a.firstname.to_s.downcase == firstname &&
528 532 a.lastname.to_s.downcase == lastname
529 533 }
530 534 end
531 535 if assignee.nil?
532 536 assignee ||= assignable.detect {|a| a.name.downcase == keyword}
533 537 end
534 538 assignee
535 539 end
536 540 end
Show file before | Show file after | Hide comments
@@ -1,869 +1,886
1 1 # encoding: utf-8
2 2 #
3 3 # Redmine - project management software
4 4 # Copyright (C) 2006-2013 Jean-Philippe Lang
5 5 #
6 6 # This program is free software; you can redistribute it and/or
7 7 # modify it under the terms of the GNU General Public License
8 8 # as published by the Free Software Foundation; either version 2
9 9 # of the License, or (at your option) any later version.
10 10 #
11 11 # This program is distributed in the hope that it will be useful,
12 12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 14 # GNU General Public License for more details.
15 15 #
16 16 # You should have received a copy of the GNU General Public License
17 17 # along with this program; if not, write to the Free Software
18 18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 19
20 20 require File.expand_path('../../test_helper', __FILE__)
21 21
22 22 class MailHandlerTest < ActiveSupport::TestCase
23 23 fixtures :users, :projects, :enabled_modules, :roles,
24 24 :members, :member_roles, :users,
25 25 :issues, :issue_statuses,
26 26 :workflows, :trackers, :projects_trackers,
27 27 :versions, :enumerations, :issue_categories,
28 28 :custom_fields, :custom_fields_trackers, :custom_fields_projects,
29 29 :boards, :messages
30 30
31 31 FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures/mail_handler'
32 32
33 33 def setup
34 34 ActionMailer::Base.deliveries.clear
35 35 Setting.notified_events = Redmine::Notifiable.all.collect(&:name)
36 36 end
37 37
38 38 def teardown
39 39 Setting.clear_cache
40 40 end
41 41
42 42 def test_add_issue
43 43 ActionMailer::Base.deliveries.clear
44 44 # This email contains: 'Project: onlinestore'
45 45 issue = submit_email('ticket_on_given_project.eml')
46 46 assert issue.is_a?(Issue)
47 47 assert !issue.new_record?
48 48 issue.reload
49 49 assert_equal Project.find(2), issue.project
50 50 assert_equal issue.project.trackers.first, issue.tracker
51 51 assert_equal 'New ticket on a given project', issue.subject
52 52 assert_equal User.find_by_login('jsmith'), issue.author
53 53 assert_equal IssueStatus.find_by_name('Resolved'), issue.status
54 54 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
55 55 assert_equal '2010-01-01', issue.start_date.to_s
56 56 assert_equal '2010-12-31', issue.due_date.to_s
57 57 assert_equal User.find_by_login('jsmith'), issue.assigned_to
58 58 assert_equal Version.find_by_name('Alpha'), issue.fixed_version
59 59 assert_equal 2.5, issue.estimated_hours
60 60 assert_equal 30, issue.done_ratio
61 61 assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
62 62 # keywords should be removed from the email body
63 63 assert !issue.description.match(/^Project:/i)
64 64 assert !issue.description.match(/^Status:/i)
65 65 assert !issue.description.match(/^Start Date:/i)
66 66 # Email notification should be sent
67 67 mail = ActionMailer::Base.deliveries.last
68 68 assert_not_nil mail
69 69 assert mail.subject.include?('New ticket on a given project')
70 70 end
71 71
72 72 def test_add_issue_with_default_tracker
73 73 # This email contains: 'Project: onlinestore'
74 74 issue = submit_email(
75 75 'ticket_on_given_project.eml',
76 76 :issue => {:tracker => 'Support request'}
77 77 )
78 78 assert issue.is_a?(Issue)
79 79 assert !issue.new_record?
80 80 issue.reload
81 81 assert_equal 'Support request', issue.tracker.name
82 82 end
83 83
84 84 def test_add_issue_with_status
85 85 # This email contains: 'Project: onlinestore' and 'Status: Resolved'
86 86 issue = submit_email('ticket_on_given_project.eml')
87 87 assert issue.is_a?(Issue)
88 88 assert !issue.new_record?
89 89 issue.reload
90 90 assert_equal Project.find(2), issue.project
91 91 assert_equal IssueStatus.find_by_name("Resolved"), issue.status
92 92 end
93 93
94 94 def test_add_issue_with_attributes_override
95 95 issue = submit_email(
96 96 'ticket_with_attributes.eml',
97 97 :allow_override => 'tracker,category,priority'
98 98 )
99 99 assert issue.is_a?(Issue)
100 100 assert !issue.new_record?
101 101 issue.reload
102 102 assert_equal 'New ticket on a given project', issue.subject
103 103 assert_equal User.find_by_login('jsmith'), issue.author
104 104 assert_equal Project.find(2), issue.project
105 105 assert_equal 'Feature request', issue.tracker.to_s
106 106 assert_equal 'Stock management', issue.category.to_s
107 107 assert_equal 'Urgent', issue.priority.to_s
108 108 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
109 109 end
110 110
111 111 def test_add_issue_with_group_assignment
112 112 with_settings :issue_group_assignment => '1' do
113 113 issue = submit_email('ticket_on_given_project.eml') do |email|
114 114 email.gsub!('Assigned to: John Smith', 'Assigned to: B Team')
115 115 end
116 116 assert issue.is_a?(Issue)
117 117 assert !issue.new_record?
118 118 issue.reload
119 119 assert_equal Group.find(11), issue.assigned_to
120 120 end
121 121 end
122 122
123 123 def test_add_issue_with_partial_attributes_override
124 124 issue = submit_email(
125 125 'ticket_with_attributes.eml',
126 126 :issue => {:priority => 'High'},
127 127 :allow_override => ['tracker']
128 128 )
129 129 assert issue.is_a?(Issue)
130 130 assert !issue.new_record?
131 131 issue.reload
132 132 assert_equal 'New ticket on a given project', issue.subject
133 133 assert_equal User.find_by_login('jsmith'), issue.author
134 134 assert_equal Project.find(2), issue.project
135 135 assert_equal 'Feature request', issue.tracker.to_s
136 136 assert_nil issue.category
137 137 assert_equal 'High', issue.priority.to_s
138 138 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
139 139 end
140 140
141 141 def test_add_issue_with_spaces_between_attribute_and_separator
142 142 issue = submit_email(
143 143 'ticket_with_spaces_between_attribute_and_separator.eml',
144 144 :allow_override => 'tracker,category,priority'
145 145 )
146 146 assert issue.is_a?(Issue)
147 147 assert !issue.new_record?
148 148 issue.reload
149 149 assert_equal 'New ticket on a given project', issue.subject
150 150 assert_equal User.find_by_login('jsmith'), issue.author
151 151 assert_equal Project.find(2), issue.project
152 152 assert_equal 'Feature request', issue.tracker.to_s
153 153 assert_equal 'Stock management', issue.category.to_s
154 154 assert_equal 'Urgent', issue.priority.to_s
155 155 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
156 156 end
157 157
158 158 def test_add_issue_with_attachment_to_specific_project
159 159 issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
160 160 assert issue.is_a?(Issue)
161 161 assert !issue.new_record?
162 162 issue.reload
163 163 assert_equal 'Ticket created by email with attachment', issue.subject
164 164 assert_equal User.find_by_login('jsmith'), issue.author
165 165 assert_equal Project.find(2), issue.project
166 166 assert_equal 'This is a new ticket with attachments', issue.description
167 167 # Attachment properties
168 168 assert_equal 1, issue.attachments.size
169 169 assert_equal 'Paella.jpg', issue.attachments.first.filename
170 170 assert_equal 'image/jpeg', issue.attachments.first.content_type
171 171 assert_equal 10790, issue.attachments.first.filesize
172 172 end
173 173
174 174 def test_add_issue_with_custom_fields
175 175 issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'onlinestore'})
176 176 assert issue.is_a?(Issue)
177 177 assert !issue.new_record?
178 178 issue.reload
179 179 assert_equal 'New ticket with custom field values', issue.subject
180 180 assert_equal 'PostgreSQL', issue.custom_field_value(1)
181 181 assert_equal 'Value for a custom field', issue.custom_field_value(2)
182 182 assert !issue.description.match(/^searchable field:/i)
183 183 end
184 184
185 185 def test_add_issue_with_version_custom_fields
186 186 field = IssueCustomField.create!(:name => 'Affected version', :field_format => 'version', :is_for_all => true, :tracker_ids => [1,2,3])
187 187
188 188 issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'ecookbook'}) do |email|
189 189 email << "Affected version: 1.0\n"
190 190 end
191 191 assert issue.is_a?(Issue)
192 192 assert !issue.new_record?
193 193 issue.reload
194 194 assert_equal '2', issue.custom_field_value(field)
195 195 end
196 196
197 197 def test_add_issue_should_match_assignee_on_display_name
198 198 user = User.generate!(:firstname => 'Foo Bar', :lastname => 'Foo Baz')
199 199 User.add_to_project(user, Project.find(2))
200 200 issue = submit_email('ticket_on_given_project.eml') do |email|
201 201 email.sub!(/^Assigned to.*$/, 'Assigned to: Foo Bar Foo baz')
202 202 end
203 203 assert issue.is_a?(Issue)
204 204 assert_equal user, issue.assigned_to
205 205 end
206 206
207 207 def test_add_issue_with_cc
208 208 issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
209 209 assert issue.is_a?(Issue)
210 210 assert !issue.new_record?
211 211 issue.reload
212 212 assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
213 213 assert_equal 1, issue.watcher_user_ids.size
214 214 end
215 215
216 216 def test_add_issue_by_unknown_user
217 217 assert_no_difference 'User.count' do
218 218 assert_equal false,
219 219 submit_email(
220 220 'ticket_by_unknown_user.eml',
221 221 :issue => {:project => 'ecookbook'}
222 222 )
223 223 end
224 224 end
225 225
226 226 def test_add_issue_by_anonymous_user
227 227 Role.anonymous.add_permission!(:add_issues)
228 228 assert_no_difference 'User.count' do
229 229 issue = submit_email(
230 230 'ticket_by_unknown_user.eml',
231 231 :issue => {:project => 'ecookbook'},
232 232 :unknown_user => 'accept'
233 233 )
234 234 assert issue.is_a?(Issue)
235 235 assert issue.author.anonymous?
236 236 end
237 237 end
238 238
239 239 def test_add_issue_by_anonymous_user_with_no_from_address
240 240 Role.anonymous.add_permission!(:add_issues)
241 241 assert_no_difference 'User.count' do
242 242 issue = submit_email(
243 243 'ticket_by_empty_user.eml',
244 244 :issue => {:project => 'ecookbook'},
245 245 :unknown_user => 'accept'
246 246 )
247 247 assert issue.is_a?(Issue)
248 248 assert issue.author.anonymous?
249 249 end
250 250 end
251 251
252 252 def test_add_issue_by_anonymous_user_on_private_project
253 253 Role.anonymous.add_permission!(:add_issues)
254 254 assert_no_difference 'User.count' do
255 255 assert_no_difference 'Issue.count' do
256 256 assert_equal false,
257 257 submit_email(
258 258 'ticket_by_unknown_user.eml',
259 259 :issue => {:project => 'onlinestore'},
260 260 :unknown_user => 'accept'
261 261 )
262 262 end
263 263 end
264 264 end
265 265
266 266 def test_add_issue_by_anonymous_user_on_private_project_without_permission_check
267 267 assert_no_difference 'User.count' do
268 268 assert_difference 'Issue.count' do
269 269 issue = submit_email(
270 270 'ticket_by_unknown_user.eml',
271 271 :issue => {:project => 'onlinestore'},
272 272 :no_permission_check => '1',
273 273 :unknown_user => 'accept'
274 274 )
275 275 assert issue.is_a?(Issue)
276 276 assert issue.author.anonymous?
277 277 assert !issue.project.is_public?
278 278 assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
279 279 end
280 280 end
281 281 end
282 282
283 283 def test_add_issue_by_created_user
284 284 Setting.default_language = 'en'
285 285 assert_difference 'User.count' do
286 286 issue = submit_email(
287 287 'ticket_by_unknown_user.eml',
288 288 :issue => {:project => 'ecookbook'},
289 289 :unknown_user => 'create'
290 290 )
291 291 assert issue.is_a?(Issue)
292 292 assert issue.author.active?
293 293 assert_equal 'john.doe@somenet.foo', issue.author.mail
294 294 assert_equal 'John', issue.author.firstname
295 295 assert_equal 'Doe', issue.author.lastname
296 296
297 297 # account information
298 298 email = ActionMailer::Base.deliveries.first
299 299 assert_not_nil email
300 300 assert email.subject.include?('account activation')
301 301 login = mail_body(email).match(/\* Login: (.*)$/)[1].strip
302 302 password = mail_body(email).match(/\* Password: (.*)$/)[1].strip
303 303 assert_equal issue.author, User.try_to_login(login, password)
304 304 end
305 305 end
306 306
307 307 def test_created_user_should_be_added_to_groups
308 308 group1 = Group.generate!
309 309 group2 = Group.generate!
310 310
311 311 assert_difference 'User.count' do
312 312 submit_email(
313 313 'ticket_by_unknown_user.eml',
314 314 :issue => {:project => 'ecookbook'},
315 315 :unknown_user => 'create',
316 316 :default_group => "#{group1.name},#{group2.name}"
317 317 )
318 318 end
319 319 user = User.order('id DESC').first
320 320 assert_same_elements [group1, group2], user.groups
321 321 end
322 322
323 323 def test_created_user_should_not_receive_account_information_with_no_account_info_option
324 324 assert_difference 'User.count' do
325 325 submit_email(
326 326 'ticket_by_unknown_user.eml',
327 327 :issue => {:project => 'ecookbook'},
328 328 :unknown_user => 'create',
329 329 :no_account_notice => '1'
330 330 )
331 331 end
332 332
333 333 # only 1 email for the new issue notification
334 334 assert_equal 1, ActionMailer::Base.deliveries.size
335 335 email = ActionMailer::Base.deliveries.first
336 336 assert_include 'Ticket by unknown user', email.subject
337 337 end
338 338
339 339 def test_created_user_should_have_mail_notification_to_none_with_no_notification_option
340 340 assert_difference 'User.count' do
341 341 submit_email(
342 342 'ticket_by_unknown_user.eml',
343 343 :issue => {:project => 'ecookbook'},
344 344 :unknown_user => 'create',
345 345 :no_notification => '1'
346 346 )
347 347 end
348 348 user = User.order('id DESC').first
349 349 assert_equal 'none', user.mail_notification
350 350 end
351 351
352 352 def test_add_issue_without_from_header
353 353 Role.anonymous.add_permission!(:add_issues)
354 354 assert_equal false, submit_email('ticket_without_from_header.eml')
355 355 end
356 356
357 357 def test_add_issue_with_invalid_attributes
358 358 issue = submit_email(
359 359 'ticket_with_invalid_attributes.eml',
360 360 :allow_override => 'tracker,category,priority'
361 361 )
362 362 assert issue.is_a?(Issue)
363 363 assert !issue.new_record?
364 364 issue.reload
365 365 assert_nil issue.assigned_to
366 366 assert_nil issue.start_date
367 367 assert_nil issue.due_date
368 368 assert_equal 0, issue.done_ratio
369 369 assert_equal 'Normal', issue.priority.to_s
370 370 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
371 371 end
372 372
373 373 def test_add_issue_with_invalid_project_should_be_assigned_to_default_project
374 374 issue = submit_email('ticket_on_given_project.eml', :issue => {:project => 'ecookbook'}, :allow_override => 'project') do |email|
375 375 email.gsub!(/^Project:.+$/, 'Project: invalid')
376 376 end
377 377 assert issue.is_a?(Issue)
378 378 assert !issue.new_record?
379 379 assert_equal 'ecookbook', issue.project.identifier
380 380 end
381 381
382 382 def test_add_issue_with_localized_attributes
383 383 User.find_by_mail('jsmith@somenet.foo').update_attribute 'language', 'fr'
384 384 issue = submit_email(
385 385 'ticket_with_localized_attributes.eml',
386 386 :allow_override => 'tracker,category,priority'
387 387 )
388 388 assert issue.is_a?(Issue)
389 389 assert !issue.new_record?
390 390 issue.reload
391 391 assert_equal 'New ticket on a given project', issue.subject
392 392 assert_equal User.find_by_login('jsmith'), issue.author
393 393 assert_equal Project.find(2), issue.project
394 394 assert_equal 'Feature request', issue.tracker.to_s
395 395 assert_equal 'Stock management', issue.category.to_s
396 396 assert_equal 'Urgent', issue.priority.to_s
397 397 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
398 398 end
399 399
400 400 def test_add_issue_with_japanese_keywords
401 401 ja_dev = "\xe9\x96\x8b\xe7\x99\xba"
402 402 ja_dev.force_encoding('UTF-8') if ja_dev.respond_to?(:force_encoding)
403 403 tracker = Tracker.create!(:name => ja_dev)
404 404 Project.find(1).trackers << tracker
405 405 issue = submit_email(
406 406 'japanese_keywords_iso_2022_jp.eml',
407 407 :issue => {:project => 'ecookbook'},
408 408 :allow_override => 'tracker'
409 409 )
410 410 assert_kind_of Issue, issue
411 411 assert_equal tracker, issue.tracker
412 412 end
413 413
414 414 def test_add_issue_from_apple_mail
415 415 issue = submit_email(
416 416 'apple_mail_with_attachment.eml',
417 417 :issue => {:project => 'ecookbook'}
418 418 )
419 419 assert_kind_of Issue, issue
420 420 assert_equal 1, issue.attachments.size
421 421
422 422 attachment = issue.attachments.first
423 423 assert_equal 'paella.jpg', attachment.filename
424 424 assert_equal 10790, attachment.filesize
425 425 assert File.exist?(attachment.diskfile)
426 426 assert_equal 10790, File.size(attachment.diskfile)
427 427 assert_equal 'caaf384198bcbc9563ab5c058acd73cd', attachment.digest
428 428 end
429 429
430 430 def test_thunderbird_with_attachment_ja
431 431 issue = submit_email(
432 432 'thunderbird_with_attachment_ja.eml',
433 433 :issue => {:project => 'ecookbook'}
434 434 )
435 435 assert_kind_of Issue, issue
436 436 assert_equal 1, issue.attachments.size
437 437 ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
438 438 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
439 439 attachment = issue.attachments.first
440 440 assert_equal ja, attachment.filename
441 441 assert_equal 5, attachment.filesize
442 442 assert File.exist?(attachment.diskfile)
443 443 assert_equal 5, File.size(attachment.diskfile)
444 444 assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
445 445 end
446 446
447 447 def test_gmail_with_attachment_ja
448 448 issue = submit_email(
449 449 'gmail_with_attachment_ja.eml',
450 450 :issue => {:project => 'ecookbook'}
451 451 )
452 452 assert_kind_of Issue, issue
453 453 assert_equal 1, issue.attachments.size
454 454 ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
455 455 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
456 456 attachment = issue.attachments.first
457 457 assert_equal ja, attachment.filename
458 458 assert_equal 5, attachment.filesize
459 459 assert File.exist?(attachment.diskfile)
460 460 assert_equal 5, File.size(attachment.diskfile)
461 461 assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
462 462 end
463 463
464 464 def test_thunderbird_with_attachment_latin1
465 465 issue = submit_email(
466 466 'thunderbird_with_attachment_iso-8859-1.eml',
467 467 :issue => {:project => 'ecookbook'}
468 468 )
469 469 assert_kind_of Issue, issue
470 470 assert_equal 1, issue.attachments.size
471 471 u = ""
472 472 u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
473 473 u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
474 474 u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
475 475 11.times { u << u1 }
476 476 attachment = issue.attachments.first
477 477 assert_equal "#{u}.png", attachment.filename
478 478 assert_equal 130, attachment.filesize
479 479 assert File.exist?(attachment.diskfile)
480 480 assert_equal 130, File.size(attachment.diskfile)
481 481 assert_equal '4d80e667ac37dddfe05502530f152abb', attachment.digest
482 482 end
483 483
484 484 def test_gmail_with_attachment_latin1
485 485 issue = submit_email(
486 486 'gmail_with_attachment_iso-8859-1.eml',
487 487 :issue => {:project => 'ecookbook'}
488 488 )
489 489 assert_kind_of Issue, issue
490 490 assert_equal 1, issue.attachments.size
491 491 u = ""
492 492 u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
493 493 u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
494 494 u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
495 495 11.times { u << u1 }
496 496 attachment = issue.attachments.first
497 497 assert_equal "#{u}.txt", attachment.filename
498 498 assert_equal 5, attachment.filesize
499 499 assert File.exist?(attachment.diskfile)
500 500 assert_equal 5, File.size(attachment.diskfile)
501 501 assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
502 502 end
503 503
504 504 def test_multiple_inline_text_parts_should_be_appended_to_issue_description
505 505 issue = submit_email('multiple_text_parts.eml', :issue => {:project => 'ecookbook'})
506 506 assert_include 'first', issue.description
507 507 assert_include 'second', issue.description
508 508 assert_include 'third', issue.description
509 509 end
510 510
511 511 def test_attachment_text_part_should_be_added_as_issue_attachment
512 512 issue = submit_email('multiple_text_parts.eml', :issue => {:project => 'ecookbook'})
513 513 assert_not_include 'Plain text attachment', issue.description
514 514 attachment = issue.attachments.detect {|a| a.filename == 'textfile.txt'}
515 515 assert_not_nil attachment
516 516 assert_include 'Plain text attachment', File.read(attachment.diskfile)
517 517 end
518 518
519 519 def test_add_issue_with_iso_8859_1_subject
520 520 issue = submit_email(
521 521 'subject_as_iso-8859-1.eml',
522 522 :issue => {:project => 'ecookbook'}
523 523 )
524 524 str = "Testmail from Webmail: \xc3\xa4 \xc3\xb6 \xc3\xbc..."
525 525 str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
526 526 assert_kind_of Issue, issue
527 527 assert_equal str, issue.subject
528 528 end
529 529
530 530 def test_add_issue_with_japanese_subject
531 531 issue = submit_email(
532 532 'subject_japanese_1.eml',
533 533 :issue => {:project => 'ecookbook'}
534 534 )
535 535 assert_kind_of Issue, issue
536 536 ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
537 537 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
538 538 assert_equal ja, issue.subject
539 539 end
540 540
541 def test_add_issue_with_korean_body
542 # Make sure mail bodies with a charset unknown to Ruby
543 # but known to the Mail gem 2.5.4 are handled correctly
544 kr = "\xEA\xB3\xA0\xEB\xA7\x99\xEC\x8A\xB5\xEB\x8B\x88\xEB\x8B\xA4."
545 if !kr.respond_to?(:force_encoding)
546 puts "\nOn Ruby 1.8, skip Korean encoding mail body test"
547 else
548 kr.force_encoding('UTF-8')
549 issue = submit_email(
550 'body_ks_c_5601-1987.eml',
551 :issue => {:project => 'ecookbook'}
552 )
553 assert_kind_of Issue, issue
554 assert_equal kr, issue.description
555 end
556 end
557
541 558 def test_add_issue_with_no_subject_header
542 559 issue = submit_email(
543 560 'no_subject_header.eml',
544 561 :issue => {:project => 'ecookbook'}
545 562 )
546 563 assert_kind_of Issue, issue
547 564 assert_equal '(no subject)', issue.subject
548 565 end
549 566
550 567 def test_add_issue_with_mixed_japanese_subject
551 568 issue = submit_email(
552 569 'subject_japanese_2.eml',
553 570 :issue => {:project => 'ecookbook'}
554 571 )
555 572 assert_kind_of Issue, issue
556 573 ja = "Re: \xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
557 574 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
558 575 assert_equal ja, issue.subject
559 576 end
560 577
561 578 def test_should_ignore_emails_from_locked_users
562 579 User.find(2).lock!
563 580
564 581 MailHandler.any_instance.expects(:dispatch).never
565 582 assert_no_difference 'Issue.count' do
566 583 assert_equal false, submit_email('ticket_on_given_project.eml')
567 584 end
568 585 end
569 586
570 587 def test_should_ignore_emails_from_emission_address
571 588 Role.anonymous.add_permission!(:add_issues)
572 589 assert_no_difference 'User.count' do
573 590 assert_equal false,
574 591 submit_email(
575 592 'ticket_from_emission_address.eml',
576 593 :issue => {:project => 'ecookbook'},
577 594 :unknown_user => 'create'
578 595 )
579 596 end
580 597 end
581 598
582 599 def test_should_ignore_auto_replied_emails
583 600 MailHandler.any_instance.expects(:dispatch).never
584 601 [
585 602 "X-Auto-Response-Suppress: OOF",
586 603 "Auto-Submitted: auto-replied",
587 604 "Auto-Submitted: Auto-Replied",
588 605 "Auto-Submitted: auto-generated"
589 606 ].each do |header|
590 607 raw = IO.read(File.join(FIXTURES_PATH, 'ticket_on_given_project.eml'))
591 608 raw = header + "\n" + raw
592 609
593 610 assert_no_difference 'Issue.count' do
594 611 assert_equal false, MailHandler.receive(raw), "email with #{header} header was not ignored"
595 612 end
596 613 end
597 614 end
598 615
599 616 def test_add_issue_should_send_email_notification
600 617 Setting.notified_events = ['issue_added']
601 618 ActionMailer::Base.deliveries.clear
602 619 # This email contains: 'Project: onlinestore'
603 620 issue = submit_email('ticket_on_given_project.eml')
604 621 assert issue.is_a?(Issue)
605 622 assert_equal 1, ActionMailer::Base.deliveries.size
606 623 end
607 624
608 625 def test_update_issue
609 626 journal = submit_email('ticket_reply.eml')
610 627 assert journal.is_a?(Journal)
611 628 assert_equal User.find_by_login('jsmith'), journal.user
612 629 assert_equal Issue.find(2), journal.journalized
613 630 assert_match /This is reply/, journal.notes
614 631 assert_equal false, journal.private_notes
615 632 assert_equal 'Feature request', journal.issue.tracker.name
616 633 end
617 634
618 635 def test_update_issue_with_attribute_changes
619 636 # This email contains: 'Status: Resolved'
620 637 journal = submit_email('ticket_reply_with_status.eml')
621 638 assert journal.is_a?(Journal)
622 639 issue = Issue.find(journal.issue.id)
623 640 assert_equal User.find_by_login('jsmith'), journal.user
624 641 assert_equal Issue.find(2), journal.journalized
625 642 assert_match /This is reply/, journal.notes
626 643 assert_equal 'Feature request', journal.issue.tracker.name
627 644 assert_equal IssueStatus.find_by_name("Resolved"), issue.status
628 645 assert_equal '2010-01-01', issue.start_date.to_s
629 646 assert_equal '2010-12-31', issue.due_date.to_s
630 647 assert_equal User.find_by_login('jsmith'), issue.assigned_to
631 648 assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value
632 649 # keywords should be removed from the email body
633 650 assert !journal.notes.match(/^Status:/i)
634 651 assert !journal.notes.match(/^Start Date:/i)
635 652 end
636 653
637 654 def test_update_issue_with_attachment
638 655 assert_difference 'Journal.count' do
639 656 assert_difference 'JournalDetail.count' do
640 657 assert_difference 'Attachment.count' do
641 658 assert_no_difference 'Issue.count' do
642 659 journal = submit_email('ticket_with_attachment.eml') do |raw|
643 660 raw.gsub! /^Subject: .*$/, 'Subject: Re: [Cookbook - Feature #2] (New) Add ingredients categories'
644 661 end
645 662 end
646 663 end
647 664 end
648 665 end
649 666 journal = Journal.first(:order => 'id DESC')
650 667 assert_equal Issue.find(2), journal.journalized
651 668 assert_equal 1, journal.details.size
652 669
653 670 detail = journal.details.first
654 671 assert_equal 'attachment', detail.property
655 672 assert_equal 'Paella.jpg', detail.value
656 673 end
657 674
658 675 def test_update_issue_should_send_email_notification
659 676 ActionMailer::Base.deliveries.clear
660 677 journal = submit_email('ticket_reply.eml')
661 678 assert journal.is_a?(Journal)
662 679 assert_equal 1, ActionMailer::Base.deliveries.size
663 680 end
664 681
665 682 def test_update_issue_should_not_set_defaults
666 683 journal = submit_email(
667 684 'ticket_reply.eml',
668 685 :issue => {:tracker => 'Support request', :priority => 'High'}
669 686 )
670 687 assert journal.is_a?(Journal)
671 688 assert_match /This is reply/, journal.notes
672 689 assert_equal 'Feature request', journal.issue.tracker.name
673 690 assert_equal 'Normal', journal.issue.priority.name
674 691 end
675 692
676 693 def test_replying_to_a_private_note_should_add_reply_as_private
677 694 private_journal = Journal.create!(:notes => 'Private notes', :journalized => Issue.find(1), :private_notes => true, :user_id => 2)
678 695
679 696 assert_difference 'Journal.count' do
680 697 journal = submit_email('ticket_reply.eml') do |email|
681 698 email.sub! %r{^In-Reply-To:.*$}, "In-Reply-To: <redmine.journal-#{private_journal.id}.20060719210421@osiris>"
682 699 end
683 700
684 701 assert_kind_of Journal, journal
685 702 assert_match /This is reply/, journal.notes
686 703 assert_equal true, journal.private_notes
687 704 end
688 705 end
689 706
690 707 def test_reply_to_a_message
691 708 m = submit_email('message_reply.eml')
692 709 assert m.is_a?(Message)
693 710 assert !m.new_record?
694 711 m.reload
695 712 assert_equal 'Reply via email', m.subject
696 713 # The email replies to message #2 which is part of the thread of message #1
697 714 assert_equal Message.find(1), m.parent
698 715 end
699 716
700 717 def test_reply_to_a_message_by_subject
701 718 m = submit_email('message_reply_by_subject.eml')
702 719 assert m.is_a?(Message)
703 720 assert !m.new_record?
704 721 m.reload
705 722 assert_equal 'Reply to the first post', m.subject
706 723 assert_equal Message.find(1), m.parent
707 724 end
708 725
709 726 def test_should_strip_tags_of_html_only_emails
710 727 issue = submit_email('ticket_html_only.eml', :issue => {:project => 'ecookbook'})
711 728 assert issue.is_a?(Issue)
712 729 assert !issue.new_record?
713 730 issue.reload
714 731 assert_equal 'HTML email', issue.subject
715 732 assert_equal 'This is a html-only email.', issue.description
716 733 end
717 734
718 735 test "truncate emails with no setting should add the entire email into the issue" do
719 736 with_settings :mail_handler_body_delimiters => '' do
720 737 issue = submit_email('ticket_on_given_project.eml')
721 738 assert_issue_created(issue)
722 739 assert issue.description.include?('---')
723 740 assert issue.description.include?('This paragraph is after the delimiter')
724 741 end
725 742 end
726 743
727 744 test "truncate emails with a single string should truncate the email at the delimiter for the issue" do
728 745 with_settings :mail_handler_body_delimiters => '---' do
729 746 issue = submit_email('ticket_on_given_project.eml')
730 747 assert_issue_created(issue)
731 748 assert issue.description.include?('This paragraph is before delimiters')
732 749 assert issue.description.include?('--- This line starts with a delimiter')
733 750 assert !issue.description.match(/^---$/)
734 751 assert !issue.description.include?('This paragraph is after the delimiter')
735 752 end
736 753 end
737 754
738 755 test "truncate emails with a single quoted reply should truncate the email at the delimiter with the quoted reply symbols (>)" do
739 756 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' do
740 757 journal = submit_email('issue_update_with_quoted_reply_above.eml')
741 758 assert journal.is_a?(Journal)
742 759 assert journal.notes.include?('An update to the issue by the sender.')
743 760 assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
744 761 assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
745 762 end
746 763 end
747 764
748 765 test "truncate emails with multiple quoted replies should truncate the email at the delimiter with the quoted reply symbols (>)" do
749 766 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' do
750 767 journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')
751 768 assert journal.is_a?(Journal)
752 769 assert journal.notes.include?('An update to the issue by the sender.')
753 770 assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
754 771 assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
755 772 end
756 773 end
757 774
758 775 test "truncate emails with multiple strings should truncate the email at the first delimiter found (BREAK)" do
759 776 with_settings :mail_handler_body_delimiters => "---\nBREAK" do
760 777 issue = submit_email('ticket_on_given_project.eml')
761 778 assert_issue_created(issue)
762 779 assert issue.description.include?('This paragraph is before delimiters')
763 780 assert !issue.description.include?('BREAK')
764 781 assert !issue.description.include?('This paragraph is between delimiters')
765 782 assert !issue.description.match(/^---$/)
766 783 assert !issue.description.include?('This paragraph is after the delimiter')
767 784 end
768 785 end
769 786
770 787 def test_attachments_that_match_mail_handler_excluded_filenames_should_be_ignored
771 788 with_settings :mail_handler_excluded_filenames => '*.vcf, *.jpg' do
772 789 issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
773 790 assert issue.is_a?(Issue)
774 791 assert !issue.new_record?
775 792 assert_equal 0, issue.reload.attachments.size
776 793 end
777 794 end
778 795
779 796 def test_attachments_that_do_not_match_mail_handler_excluded_filenames_should_be_attached
780 797 with_settings :mail_handler_excluded_filenames => '*.vcf, *.gif' do
781 798 issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
782 799 assert issue.is_a?(Issue)
783 800 assert !issue.new_record?
784 801 assert_equal 1, issue.reload.attachments.size
785 802 end
786 803 end
787 804
788 805 def test_email_with_long_subject_line
789 806 issue = submit_email('ticket_with_long_subject.eml')
790 807 assert issue.is_a?(Issue)
791 808 assert_equal issue.subject, 'New ticket on a given project with a very long subject line which exceeds 255 chars and should not be ignored but chopped off. And if the subject line is still not long enough, we just add more text. And more text. Wow, this is really annoying. Especially, if you have nothing to say...'[0,255]
792 809 end
793 810
794 811 def test_new_user_from_attributes_should_return_valid_user
795 812 to_test = {
796 813 # [address, name] => [login, firstname, lastname]
797 814 ['jsmith@example.net', nil] => ['jsmith@example.net', 'jsmith', '-'],
798 815 ['jsmith@example.net', 'John'] => ['jsmith@example.net', 'John', '-'],
799 816 ['jsmith@example.net', 'John Smith'] => ['jsmith@example.net', 'John', 'Smith'],
800 817 ['jsmith@example.net', 'John Paul Smith'] => ['jsmith@example.net', 'John', 'Paul Smith'],
801 818 ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsTheMaximumLength Smith'] => ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsT', 'Smith'],
802 819 ['jsmith@example.net', 'John AVeryLongLastnameThatExceedsTheMaximumLength'] => ['jsmith@example.net', 'John', 'AVeryLongLastnameThatExceedsTh']
803 820 }
804 821
805 822 to_test.each do |attrs, expected|
806 823 user = MailHandler.new_user_from_attributes(attrs.first, attrs.last)
807 824
808 825 assert user.valid?, user.errors.full_messages.to_s
809 826 assert_equal attrs.first, user.mail
810 827 assert_equal expected[0], user.login
811 828 assert_equal expected[1], user.firstname
812 829 assert_equal expected[2], user.lastname
813 830 assert_equal 'only_my_events', user.mail_notification
814 831 end
815 832 end
816 833
817 834 def test_new_user_from_attributes_should_use_default_login_if_invalid
818 835 user = MailHandler.new_user_from_attributes('foo+bar@example.net')
819 836 assert user.valid?
820 837 assert user.login =~ /^user[a-f0-9]+$/
821 838 assert_equal 'foo+bar@example.net', user.mail
822 839 end
823 840
824 841 def test_new_user_with_utf8_encoded_fullname_should_be_decoded
825 842 assert_difference 'User.count' do
826 843 issue = submit_email(
827 844 'fullname_of_sender_as_utf8_encoded.eml',
828 845 :issue => {:project => 'ecookbook'},
829 846 :unknown_user => 'create'
830 847 )
831 848 end
832 849
833 850 user = User.first(:order => 'id DESC')
834 851 assert_equal "foo@example.org", user.mail
835 852 str1 = "\xc3\x84\xc3\xa4"
836 853 str2 = "\xc3\x96\xc3\xb6"
837 854 str1.force_encoding('UTF-8') if str1.respond_to?(:force_encoding)
838 855 str2.force_encoding('UTF-8') if str2.respond_to?(:force_encoding)
839 856 assert_equal str1, user.firstname
840 857 assert_equal str2, user.lastname
841 858 end
842 859
843 860 def test_extract_options_from_env_should_return_options
844 861 options = MailHandler.extract_options_from_env({
845 862 'tracker' => 'defect',
846 863 'project' => 'foo',
847 864 'unknown_user' => 'create'
848 865 })
849 866
850 867 assert_equal({
851 868 :issue => {:tracker => 'defect', :project => 'foo'},
852 869 :unknown_user => 'create'
853 870 }, options)
854 871 end
855 872
856 873 private
857 874
858 875 def submit_email(filename, options={})
859 876 raw = IO.read(File.join(FIXTURES_PATH, filename))
860 877 yield raw if block_given?
861 878 MailHandler.receive(raw, options)
862 879 end
863 880
864 881 def assert_issue_created(issue)
865 882 assert issue.is_a?(Issue)
866 883 assert !issue.new_record?
867 884 issue.reload
868 885 end
869 886 end
General Comments 0
You need to be logged in to leave comments. Login now