jro_apps/redmine Commit - r10627:f578a5c4f6a9

Merged r10852 from trunk (#12399)...

Toshi MARUYAMA -

r10627:f578a5c4f6a9

parent child

Context file:

r10627:f578a5c4f6a9

Collapse all files

test/fixtures/mail_handler/gmail_with_attachment_iso-8859-1.eml created 644 +26 0

@@ -0,0 +1,26
	1	Date: Tue, 20 Nov 2012 23:08:25 +0900
	2	Message-ID: <CANBr5-UZM=Odz4U3Q6vHd_9cd2tCT-_P9xDd=hRJ0aoMNTWXbw@mail.gmail.com>
	3	Subject: test
	4	From: John Smith <JSmith@somenet.foo>
	5	To: redmine@somenet.foo
	6	Content-Type: multipart/mixed; boundary=14dae93a13bf76ca5d04ceedc458
	7
	8	--14dae93a13bf76ca5d04ceedc458
	9	Content-Type: text/plain; charset=ISO-8859-1
	10
	11	test
	12
	13	--14dae93a13bf76ca5d04ceedc458
	14	Content-Type: text/plain; charset=US-ASCII;
	15	name="=?ISO-8859-1?B?xOTW9tz8xOTW9tz8xOTW9tz8xOTW9tz8xOTW9tw=?=
	16	=?ISO-8859-1?B?/MTk1vbc/MTk1vbc/MTk1vbc/MTk1vbc/MTk1vbc?=
	17	=?ISO-8859-1?B?/MTk1vbc/C50eHQ=?="
	18	Content-Disposition: attachment;
	19	filename="=?ISO-8859-1?B?xOTW9tz8xOTW9tz8xOTW9tz8xOTW9tz8xOTW9tw=?=
	20	=?ISO-8859-1?B?/MTk1vbc/MTk1vbc/MTk1vbc/MTk1vbc/MTk1vbc?=
	21	=?ISO-8859-1?B?/MTk1vbc/C50eHQ=?="
	22	Content-Transfer-Encoding: base64
	23	X-Attachment-Id: f_h9r3mcjz0
	24
	25	dGVzdAo=
	26	--14dae93a13bf76ca5d04ceedc458--

test/fixtures/mail_handler/gmail_with_attachment_ja.eml created 644 +20 0

@@ -0,0 +1,20
	1	Date: Mon, 19 Nov 2012 10:17:45 +0900
	2	Message-ID: <CANBr5-U6cXMfLek5QiB2ZrBPR3vTThn9_Upvdkf3Dkod664+Xw@mail.gmail.com>
	3	Subject: test
	4	From: John Smith <JSmith@somenet.foo>
	5	To: redmine@somenet.foo
	6	Content-Type: multipart/mixed; boundary=bcaec54ee4ea84f77904cecee22e
	7
	8	--bcaec54ee4ea84f77904cecee22e
	9	Content-Type: text/plain; charset=ISO-8859-1
	10
	11	test
	12
	13	--bcaec54ee4ea84f77904cecee22e
	14	Content-Type: text/plain; charset=US-ASCII; name="=?ISO-2022-JP?B?GyRCJUYlOSVIGyhCLnR4dA==?="
	15	Content-Disposition: attachment; filename="=?ISO-2022-JP?B?GyRCJUYlOSVIGyhCLnR4dA==?="
	16	Content-Transfer-Encoding: base64
	17	X-Attachment-Id: f_h9owndpv0
	18
	19	dGVzdAo=
	20	--bcaec54ee4ea84f77904cecee22e--

test/fixtures/mail_handler/thunderbird_with_attachment_iso-8859-1.eml created 644 +34 0

@@ -0,0 +1,34
	1	Message-ID: <50AB9546.7020800@gmail.com>
	2	Date: Tue, 20 Nov 2012 23:35:50 +0900
	3	From: John Smith <JSmith@somenet.foo>
	4	User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.17) Gecko/20110428 Fedora/3.1.10-1.fc13 Thunderbird/3.1.10
	5	MIME-Version: 1.0
	6	To: redmine@somenet.foo
	7	Subject: test
	8	Content-Type: multipart/mixed;
	9	boundary="------------050902080306030406090208"
	10
	11	This is a multi-part message in MIME format.
	12	--------------050902080306030406090208
	13	Content-Type: text/plain; charset=ISO-8859-1; format=flowed
	14	Content-Transfer-Encoding: 7bit
	15
	16	test
	17
	18	--------------050902080306030406090208
	19	Content-Type: image/png;
	20	name="=?ISO-8859-1?Q?=C4=E4=D6=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4?=
	21	=?ISO-8859-1?Q?=D6=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4=D6?=
	22	=?ISO-8859-1?Q?=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4=D6=F6=DC=FC=C4=E4=D6=F6?=
	23	=?ISO-8859-1?Q?=DC=FC=C4=E4=D6=F6=DC=FC=2Epng?="
	24	Content-Transfer-Encoding: base64
	25	Content-Disposition: attachment;
	26	filename0=ISO-8859-1''%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6;
	27	filename1=%DC%FC%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC;
	28	filename2=%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC%C4%E4;
	29	filename3=%D6%F6%DC%FC%C4%E4%D6%F6%DC%FC%2E%70%6E%67
	30
	31	iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAIAAAACDbGyAAAAAXNSR0IArs4c6QAAAAlwSFlz
	32	AAALEwAACxMBAJqcGAAAAAd0SU1FB9wLFA4fJhRKIUQAAAAUSURBVAjXY/z//z8DEmBiQAWk
	33	8gHq9gMHP8uZWAAAAABJRU5ErkJggg==
	34	--------------050902080306030406090208--

test/fixtures/mail_handler/thunderbird_with_attachment_ja.eml created 644 +26 0

@@ -0,0 +1,26
	1	Message-ID: <50AA00C6.4070108@gmail.com>
	2	Date: Mon, 19 Nov 2012 18:49:58 +0900
	3	From: John Smith <JSmith@somenet.foo>
	4	User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.15) Gecko/20101027 Fedora/3.0.10-1.fc12 Lightning/1.0b1 Thunderbird/3.0.10
	5	MIME-Version: 1.0
	6	To: redmine@somenet.foo
	7	Subject: test
	8	Content-Type: multipart/mixed;
	9	boundary="------------030104060902010800050907"
	10
	11	This is a multi-part message in MIME format.
	12	--------------030104060902010800050907
	13	Content-Type: text/plain; charset=ISO-2022-JP
	14	Content-Transfer-Encoding: 7bit
	15
	16	test
	17
	18	--------------030104060902010800050907
	19	Content-Type: text/plain;
	20	name="=?ISO-2022-JP?B?GyRCJUYlOSVIGyhCLnR4dA==?="
	21	Content-Transfer-Encoding: base64
	22	Content-Disposition: attachment;
	23	filename*=ISO-2022-JP''%1B%24%42%25%46%25%39%25%48%1B%28%42%2E%74%78%74
	24
	25	dGVzdAo=
	26	--------------030104060902010800050907--

app/models/mail_handler.rb +18 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class MailHandler < ActionMailer::Base
               include ActionView::Helpers::SanitizeHelper
               include Redmine::I18n
               class UnauthorizedAction < StandardError; end
               class MissingInformation < StandardError; end
               attr_reader :email, :user
               def self.receive(email, options={})
                 @@handler_options = options.dup
                 @@handler_options[:issue] ||= {}
                 if @@handler_options[:allow_override].is_a?(String)
                   @@handler_options[:allow_override] = @@handler_options[:allow_override].split(',').collect(&:strip)
                 end
                 @@handler_options[:allow_override] ||= []
                 # Project needs to be overridable if not specified
                 @@handler_options[:allow_override] << 'project' unless @@handler_options[:issue].has_key?(:project)
                 # Status overridable by default
                 @@handler_options[:allow_override] << 'status' unless @@handler_options[:issue].has_key?(:status)
                 @@handler_options[:no_permission_check] = (@@handler_options[:no_permission_check].to_s == '1' ? true : false)
                 email.force_encoding('ASCII-8BIT') if email.respond_to?(:force_encoding)
                 super(email)
               end
               def logger
                 Rails.logger
               end
               cattr_accessor :ignored_emails_headers
               @@ignored_emails_headers = {
                 'X-Auto-Response-Suppress' => 'oof',
                 'Auto-Submitted' => /^auto-/
               }
               # Processes incoming emails
               # Returns the created object (eg. an issue, a message) or false
               def receive(email)
                 @email = email
                 sender_email = email.from.to_a.first.to_s.strip
                 # Ignore emails received from the application emission address to avoid hell cycles
                 if sender_email.downcase == Setting.mail_from.to_s.strip.downcase
                   if logger && logger.info
                     logger.info  "MailHandler: ignoring email from Redmine emission address [#{sender_email}]"
                   end
                   return false
                 end
                 # Ignore auto generated emails
                 self.class.ignored_emails_headers.each do |key, ignored_value|
                   value = email.header[key]
                   if value
                     value = value.to_s.downcase
                     if (ignored_value.is_a?(Regexp) && value.match(ignored_value)) || value == ignored_value
                       if logger && logger.info
                         logger.info "MailHandler: ignoring email with #{key}:#{value} header"
                       end
                       return false
                     end
                   end
                 end
                 @user = User.find_by_mail(sender_email) if sender_email.present?
                 if @user && !@user.active?
                   if logger && logger.info
                     logger.info  "MailHandler: ignoring email from non-active user [#{@user.login}]"
                   end
                   return false
                 end
                 if @user.nil?
                   # Email was submitted by an unknown user
                   case @@handler_options[:unknown_user]
                   when 'accept'
                     @user = User.anonymous
                   when 'create'
                     @user = create_user_from_email
                     if @user
                       if logger && logger.info
                         logger.info "MailHandler: [#{@user.login}] account created"
                       end
                       Mailer.account_information(@user, @user.password).deliver
                     else
                       if logger && logger.error
                         logger.error "MailHandler: could not create account for [#{sender_email}]"
                       end
                       return false
                     end
                   else
                     # Default behaviour, emails from unknown users are ignored
                     if logger && logger.info
                       logger.info  "MailHandler: ignoring email from unknown user [#{sender_email}]"
                     end
                     return false
                   end
                 end
                 User.current = @user
                 dispatch
               end
               private
               MESSAGE_ID_RE = %r{^<?redmine\.([a-z0-9_]+)\-(\d+)\.\d+@}
               ISSUE_REPLY_SUBJECT_RE = %r{\[[^\]]*#(\d+)\]}
               MESSAGE_REPLY_SUBJECT_RE = %r{\[[^\]]*msg(\d+)\]}
               def dispatch
                 headers = [email.in_reply_to, email.references].flatten.compact
                 if headers.detect {|h| h.to_s =~ MESSAGE_ID_RE}
                   klass, object_id = $1, $2.to_i
                   method_name = "receive_#{klass}_reply"
                   if self.class.private_instance_methods.collect(&:to_s).include?(method_name)
                     send method_name, object_id
                   else
                     # ignoring it
                   end
                 elsif m = email.subject.match(ISSUE_REPLY_SUBJECT_RE)
                   receive_issue_reply(m[1].to_i)
                 elsif m = email.subject.match(MESSAGE_REPLY_SUBJECT_RE)
                   receive_message_reply(m[1].to_i)
                 else
                   dispatch_to_default
                 end
               rescue ActiveRecord::RecordInvalid => e
                 # TODO: send a email to the user
                 logger.error e.message if logger
                 false
               rescue MissingInformation => e
                 logger.error "MailHandler: missing information from #{user}: #{e.message}" if logger
                 false
               rescue UnauthorizedAction => e
                 logger.error "MailHandler: unauthorized attempt from #{user}" if logger
                 false
               end
               def dispatch_to_default
                 receive_issue
               end
               # Creates a new issue
               def receive_issue
                 project = target_project
                 # check permission
                 unless @@handler_options[:no_permission_check]
                   raise UnauthorizedAction unless user.allowed_to?(:add_issues, project)
                 end
                 issue = Issue.new(:author => user, :project => project)
                 issue.safe_attributes = issue_attributes_from_keywords(issue)
                 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
                 issue.subject = cleaned_up_subject
                 if issue.subject.blank?
                   issue.subject = '(no subject)'
                 end
                 issue.description = cleaned_up_text_body
                 # add To and Cc as watchers before saving so the watchers can reply to Redmine
                 add_watchers(issue)
                 issue.save!
                 add_attachments(issue)
                 logger.info "MailHandler: issue ##{issue.id} created by #{user}" if logger && logger.info
                 issue
               end
               # Adds a note to an existing issue
               def receive_issue_reply(issue_id)
                 issue = Issue.find_by_id(issue_id)
                 return unless issue
                 # check permission
                 unless @@handler_options[:no_permission_check]
                   unless user.allowed_to?(:add_issue_notes, issue.project) ||
                            user.allowed_to?(:edit_issues, issue.project)
                     raise UnauthorizedAction
                   end
                 end
                 # ignore CLI-supplied defaults for new issues
                 @@handler_options[:issue].clear
                 journal = issue.init_journal(user)
                 issue.safe_attributes = issue_attributes_from_keywords(issue)
                 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
                 journal.notes = cleaned_up_text_body
                 add_attachments(issue)
                 issue.save!
                 if logger && logger.info
                   logger.info "MailHandler: issue ##{issue.id} updated by #{user}"
                 end
                 journal
               end
               # Reply will be added to the issue
               def receive_journal_reply(journal_id)
                 journal = Journal.find_by_id(journal_id)
                 if journal && journal.journalized_type == 'Issue'
                   receive_issue_reply(journal.journalized_id)
                 end
               end
               # Receives a reply to a forum message
               def receive_message_reply(message_id)
                 message = Message.find_by_id(message_id)
                 if message
                   message = message.root
                   unless @@handler_options[:no_permission_check]
                     raise UnauthorizedAction unless user.allowed_to?(:add_messages, message.project)
                   end
                   if !message.locked?
                     reply = Message.new(:subject => cleaned_up_subject.gsub(%r{^.*msg\d+\]}, '').strip,
                                         :content => cleaned_up_text_body)
                     reply.author = user
                     reply.board = message.board
                     message.children << reply
                     add_attachments(reply)
                     reply
                   else
                     if logger && logger.info
                       logger.info "MailHandler: ignoring reply from [#{sender_email}] to a locked topic"
                     end
                   end
                 end
               end
               def add_attachments(obj)
                 if email.attachments && email.attachments.any?
                   email.attachments.each do |attachment|
+                    filename = attachment.filename
+                    unless filename.respond_to?(:encoding)
+                      # try to reencode to utf8 manually with ruby1.8
+                      h = attachment.header['Content-Disposition']
+                      unless h.nil?
+                        begin
+                          if m = h.value.match(/filename\*[0-9\*]*=([^=']+)'/)
+                            filename = Redmine::CodesetUtil.to_utf8(filename, m[1])
+                          elsif m = h.value.match(/filename=.*=\?([^\?]+)\?[BbQq]\?/)
+                            # http://tools.ietf.org/html/rfc2047#section-4
+                            filename = Redmine::CodesetUtil.to_utf8(filename, m[1])
+                          end
+                        rescue
+                          # nop
+                        end
+                      end
+                    end
                     obj.attachments << Attachment.create(:container => obj,
                                       :file => attachment.decoded,
-                                      :filename => attachment.filename,
+                                      :filename => filename,
                                       :author => user,
                                       :content_type => attachment.mime_type)
                   end
                 end
               end
               # Adds To and Cc as watchers of the given object if the sender has the
               # appropriate permission
               def add_watchers(obj)
                 if user.allowed_to?("add_#{obj.class.name.underscore}_watchers".to_sym, obj.project)
                   addresses = [email.to, email.cc].flatten.compact.uniq.collect {|a| a.strip.downcase}
                   unless addresses.empty?
                     watchers = User.active.find(:all, :conditions => ['LOWER(mail) IN (?)', addresses])
                     watchers.each {|w| obj.add_watcher(w)}
                   end
                 end
               end
               def get_keyword(attr, options={})
                 @keywords ||= {}
                 if @keywords.has_key?(attr)
                   @keywords[attr]
                 else
                   @keywords[attr] = begin
                     if (options[:override] || @@handler_options[:allow_override].include?(attr.to_s)) &&
                           (v = extract_keyword!(plain_text_body, attr, options[:format]))
                       v
                     elsif !@@handler_options[:issue][attr].blank?
                       @@handler_options[:issue][attr]
                     end
                   end
                 end
               end
               # Destructively extracts the value for +attr+ in +text+
               # Returns nil if no matching keyword found
               def extract_keyword!(text, attr, format=nil)
                 keys = [attr.to_s.humanize]
                 if attr.is_a?(Symbol)
                   if user && user.language.present?
                     keys << l("field_#{attr}", :default => '', :locale =>  user.language)
                   end
                   if Setting.default_language.present?
                     keys << l("field_#{attr}", :default => '', :locale =>  Setting.default_language)
                   end
                 end
                 keys.reject! {|k| k.blank?}
                 keys.collect! {|k| Regexp.escape(k)}
                 format ||= '.+'
                 keyword = nil
                 regexp = /^(#{keys.join('|')})[ \t]*:[ \t]*(#{format})\s*$/i
                 if m = text.match(regexp)
                   keyword = m[2].strip
                   text.gsub!(regexp, '')
                 end
                 keyword
               end
               def target_project
                 # TODO: other ways to specify project:
                 # * parse the email To field
                 # * specific project (eg. Setting.mail_handler_target_project)
                 target = Project.find_by_identifier(get_keyword(:project))
                 raise MissingInformation.new('Unable to determine target project') if target.nil?
                 target
               end
               # Returns a Hash of issue attributes extracted from keywords in the email body
               def issue_attributes_from_keywords(issue)
                 assigned_to = (k = get_keyword(:assigned_to, :override => true)) && find_assignee_from_keyword(k, issue)
                 attrs = {
                   'tracker_id' => (k = get_keyword(:tracker)) && issue.project.trackers.named(k).first.try(:id),
                   'status_id' =>  (k = get_keyword(:status)) && IssueStatus.named(k).first.try(:id),
                   'priority_id' => (k = get_keyword(:priority)) && IssuePriority.named(k).first.try(:id),
                   'category_id' => (k = get_keyword(:category)) && issue.project.issue_categories.named(k).first.try(:id),
                   'assigned_to_id' => assigned_to.try(:id),
                   'fixed_version_id' => (k = get_keyword(:fixed_version, :override => true)) &&
                                             issue.project.shared_versions.named(k).first.try(:id),
                   'start_date' => get_keyword(:start_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                   'due_date' => get_keyword(:due_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                   'estimated_hours' => get_keyword(:estimated_hours, :override => true),
                   'done_ratio' => get_keyword(:done_ratio, :override => true, :format => '(\d|10)?0')
                 }.delete_if {|k, v| v.blank? }
                 if issue.new_record? && attrs['tracker_id'].nil?
                   attrs['tracker_id'] = issue.project.trackers.find(:first).try(:id)
                 end
                 attrs
               end
               # Returns a Hash of issue custom field values extracted from keywords in the email body
               def custom_field_values_from_keywords(customized)
                 customized.custom_field_values.inject({}) do |h, v|
                   if keyword = get_keyword(v.custom_field.name, :override => true)
                     h[v.custom_field.id.to_s] = v.custom_field.value_from_keyword(keyword, customized)
                   end
                   h
                 end
               end
               # Returns the text/plain part of the email
               # If not found (eg. HTML-only email), returns the body with tags removed
               def plain_text_body
                 return @plain_text_body unless @plain_text_body.nil?
                 part = email.text_part || email.html_part || email
                 @plain_text_body = Redmine::CodesetUtil.to_utf8(part.body.decoded, part.charset)
                 # strip html tags and remove doctype directive
                 @plain_text_body = strip_tags(@plain_text_body.strip)
                 @plain_text_body.sub! %r{^<!DOCTYPE .*$}, ''
                 @plain_text_body
               end
               def cleaned_up_text_body
                 cleanup_body(plain_text_body)
               end
               def cleaned_up_subject
                 subject = email.subject.to_s
                 unless subject.respond_to?(:encoding)
                   # try to reencode to utf8 manually with ruby1.8
                   begin
                     if h = email.header[:subject]
                       # http://tools.ietf.org/html/rfc2047#section-4
                       if m = h.value.match(/=\?([^\?]+)\?[BbQq]\?/)
                         subject = Redmine::CodesetUtil.to_utf8(subject, m[1])
                       end
                     end
                   rescue
                     # nop
                   end
                 end
                 subject.strip[0,255]
               end
               def self.full_sanitizer
                 @full_sanitizer ||= HTML::FullSanitizer.new
               end
               def self.assign_string_attribute_with_limit(object, attribute, value, limit=nil)
                 limit ||= object.class.columns_hash[attribute.to_s].limit || 255
                 value = value.to_s.slice(0, limit)
                 object.send("#{attribute}=", value)
               end
               # Returns a User from an email address and a full name
               def self.new_user_from_attributes(email_address, fullname=nil)
                 user = User.new
                 # Truncating the email address would result in an invalid format
                 user.mail = email_address
                 assign_string_attribute_with_limit(user, 'login', email_address, User::LOGIN_LENGTH_LIMIT)
                 names = fullname.blank? ? email_address.gsub(/@.*$/, '').split('.') : fullname.split
                 assign_string_attribute_with_limit(user, 'firstname', names.shift)
                 assign_string_attribute_with_limit(user, 'lastname', names.join(' '))
                 user.lastname = '-' if user.lastname.blank?
                 password_length = [Setting.password_min_length.to_i, 10].max
                 user.password = Redmine::Utils.random_hex(password_length / 2 + 1)
                 user.language = Setting.default_language
                 unless user.valid?
                   user.login = "user#{Redmine::Utils.random_hex(6)}" unless user.errors[:login].blank?
                   user.firstname = "-" unless user.errors[:firstname].blank?
                   user.lastname  = "-" unless user.errors[:lastname].blank?
                 end
                 user
               end
               # Creates a User for the +email+ sender
               # Returns the user or nil if it could not be created
               def create_user_from_email
                 from = email.header['from'].to_s
                 addr, name = from, nil
                 if m = from.match(/^"?(.+?)"?\s+<(.+@.+)>$/)
                   addr, name = m[2], m[1]
                 end
                 if addr.present?
                   user = self.class.new_user_from_attributes(addr, name)
                   if user.save
                     user
                   else
                     logger.error "MailHandler: failed to create User: #{user.errors.full_messages}" if logger
                     nil
                   end
                 else
                   logger.error "MailHandler: failed to create User: no FROM address found" if logger
                   nil
                 end
               end
               # Removes the email body of text after the truncation configurations.
               def cleanup_body(body)
                 delimiters = Setting.mail_handler_body_delimiters.to_s.split(/[\r\n]+/).reject(&:blank?).map {|s| Regexp.escape(s)}
                 unless delimiters.empty?
                   regex = Regexp.new("^[> ]*(#{ delimiters.join('|') })\s*[\r\n].*", Regexp::MULTILINE)
                   body = body.gsub(regex, '')
                 end
                 body.strip
               end
               def find_assignee_from_keyword(keyword, issue)
                 keyword = keyword.to_s.downcase
                 assignable = issue.assignable_users
                 assignee = nil
                 assignee ||= assignable.detect {|a|
                                a.mail.to_s.downcase == keyword ||
                                  a.login.to_s.downcase == keyword
                              }
                 if assignee.nil? && keyword.match(/ /)
                   firstname, lastname = *(keyword.split) # "First Last Throwaway"
                   assignee ||= assignable.detect {|a|
                                  a.is_a?(User) && a.firstname.to_s.downcase == firstname &&
                                    a.lastname.to_s.downcase == lastname
                                }
                 end
                 if assignee.nil?
                   assignee ||= assignable.detect {|a| a.name.downcase == keyword}
                 end
                 assignee
               end
             end

test/unit/mail_handler_test.rb +74 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class MailHandlerTest < ActiveSupport::TestCase
               fixtures :users, :projects, :enabled_modules, :roles,
                        :members, :member_roles, :users,
                        :issues, :issue_statuses,
                        :workflows, :trackers, :projects_trackers,
                        :versions, :enumerations, :issue_categories,
                        :custom_fields, :custom_fields_trackers, :custom_fields_projects,
                        :boards, :messages
               FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures/mail_handler'
               def setup
                 ActionMailer::Base.deliveries.clear
                 Setting.notified_events = Redmine::Notifiable.all.collect(&:name)
               end
               def teardown
                 Setting.clear_cache
               end
               def test_add_issue
                 ActionMailer::Base.deliveries.clear
                 # This email contains: 'Project: onlinestore'
                 issue = submit_email('ticket_on_given_project.eml')
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal Project.find(2), issue.project
                 assert_equal issue.project.trackers.first, issue.tracker
                 assert_equal 'New ticket on a given project', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal IssueStatus.find_by_name('Resolved'), issue.status
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                 assert_equal '2010-01-01', issue.start_date.to_s
                 assert_equal '2010-12-31', issue.due_date.to_s
                 assert_equal User.find_by_login('jsmith'), issue.assigned_to
                 assert_equal Version.find_by_name('Alpha'), issue.fixed_version
                 assert_equal 2.5, issue.estimated_hours
                 assert_equal 30, issue.done_ratio
                 assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                 # keywords should be removed from the email body
                 assert !issue.description.match(/^Project:/i)
                 assert !issue.description.match(/^Status:/i)
                 assert !issue.description.match(/^Start Date:/i)
                 # Email notification should be sent
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.include?('New ticket on a given project')
               end
               def test_add_issue_with_default_tracker
                 # This email contains: 'Project: onlinestore'
                 issue = submit_email(
                           'ticket_on_given_project.eml',
                           :issue => {:tracker => 'Support request'}
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'Support request', issue.tracker.name
               end
               def test_add_issue_with_status
                 # This email contains: 'Project: onlinestore' and 'Status: Resolved'
                 issue = submit_email('ticket_on_given_project.eml')
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal Project.find(2), issue.project
                 assert_equal IssueStatus.find_by_name("Resolved"), issue.status
               end
               def test_add_issue_with_attributes_override
                 issue = submit_email(
                           'ticket_with_attributes.eml',
                           :allow_override => 'tracker,category,priority'
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket on a given project', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal Project.find(2), issue.project
                 assert_equal 'Feature request', issue.tracker.to_s
                 assert_equal 'Stock management', issue.category.to_s
                 assert_equal 'Urgent', issue.priority.to_s
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
               end
               def test_add_issue_with_group_assignment
                 with_settings :issue_group_assignment => '1' do
                   issue = submit_email('ticket_on_given_project.eml') do |email|
                     email.gsub!('Assigned to: John Smith', 'Assigned to: B Team')
                   end
                   assert issue.is_a?(Issue)
                   assert !issue.new_record?
                   issue.reload
                   assert_equal Group.find(11), issue.assigned_to
                 end
               end
               def test_add_issue_with_partial_attributes_override
                 issue = submit_email(
                           'ticket_with_attributes.eml',
                           :issue => {:priority => 'High'},
                           :allow_override => ['tracker']
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket on a given project', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal Project.find(2), issue.project
                 assert_equal 'Feature request', issue.tracker.to_s
                 assert_nil issue.category
                 assert_equal 'High', issue.priority.to_s
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
               end
               def test_add_issue_with_spaces_between_attribute_and_separator
                 issue = submit_email(
                           'ticket_with_spaces_between_attribute_and_separator.eml',
                           :allow_override => 'tracker,category,priority'
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket on a given project', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal Project.find(2), issue.project
                 assert_equal 'Feature request', issue.tracker.to_s
                 assert_equal 'Stock management', issue.category.to_s
                 assert_equal 'Urgent', issue.priority.to_s
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
               end
               def test_add_issue_with_attachment_to_specific_project
                 issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'Ticket created by email with attachment', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal Project.find(2), issue.project
                 assert_equal 'This is  a new ticket with attachments', issue.description
                 # Attachment properties
                 assert_equal 1, issue.attachments.size
                 assert_equal 'Paella.jpg', issue.attachments.first.filename
                 assert_equal 'image/jpeg', issue.attachments.first.content_type
                 assert_equal 10790, issue.attachments.first.filesize
               end
               def test_add_issue_with_custom_fields
                 issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'onlinestore'})
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket with custom field values', issue.subject
                 assert_equal 'Value for a custom field',
                              issue.custom_value_for(CustomField.find_by_name('Searchable field')).value
                 assert !issue.description.match(/^searchable field:/i)
               end
               def test_add_issue_with_version_custom_fields
                 field = IssueCustomField.create!(:name => 'Affected version', :field_format => 'version', :is_for_all => true, :tracker_ids => [1,2,3])
                 issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'ecookbook'}) do |email|
                   email << "Affected version: 1.0\n"
                 end
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal '2', issue.custom_field_value(field)
               end
               def test_add_issue_should_match_assignee_on_display_name
                 user = User.generate!(:firstname => 'Foo Bar', :lastname => 'Foo Baz')
                 User.add_to_project(user, Project.find(2))
                 issue = submit_email('ticket_on_given_project.eml') do |email|
                   email.sub!(/^Assigned to.*$/, 'Assigned to: Foo Bar Foo baz')
                 end
                 assert issue.is_a?(Issue)
                 assert_equal user, issue.assigned_to
               end
               def test_add_issue_with_cc
                 issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
                 assert_equal 1, issue.watcher_user_ids.size
               end
               def test_add_issue_by_unknown_user
                 assert_no_difference 'User.count' do
                   assert_equal false,
                                submit_email(
                                  'ticket_by_unknown_user.eml',
                                  :issue => {:project => 'ecookbook'}
                                )
                 end
               end
               def test_add_issue_by_anonymous_user
                 Role.anonymous.add_permission!(:add_issues)
                 assert_no_difference 'User.count' do
                   issue = submit_email(
                             'ticket_by_unknown_user.eml',
                             :issue => {:project => 'ecookbook'},
                             :unknown_user => 'accept'
                           )
                   assert issue.is_a?(Issue)
                   assert issue.author.anonymous?
                 end
               end
               def test_add_issue_by_anonymous_user_with_no_from_address
                 Role.anonymous.add_permission!(:add_issues)
                 assert_no_difference 'User.count' do
                   issue = submit_email(
                             'ticket_by_empty_user.eml',
                             :issue => {:project => 'ecookbook'},
                             :unknown_user => 'accept'
                           )
                   assert issue.is_a?(Issue)
                   assert issue.author.anonymous?
                 end
               end
               def test_add_issue_by_anonymous_user_on_private_project
                 Role.anonymous.add_permission!(:add_issues)
                 assert_no_difference 'User.count' do
                   assert_no_difference 'Issue.count' do
                     assert_equal false,
                                  submit_email(
                                    'ticket_by_unknown_user.eml',
                                    :issue => {:project => 'onlinestore'},
                                    :unknown_user => 'accept'
                                  )
                   end
                 end
               end
               def test_add_issue_by_anonymous_user_on_private_project_without_permission_check
                 assert_no_difference 'User.count' do
                   assert_difference 'Issue.count' do
                     issue = submit_email(
                               'ticket_by_unknown_user.eml',
                               :issue => {:project => 'onlinestore'},
                               :no_permission_check => '1',
                               :unknown_user => 'accept'
                             )
                     assert issue.is_a?(Issue)
                     assert issue.author.anonymous?
                     assert !issue.project.is_public?
                     assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                   end
                 end
               end
               def test_add_issue_by_created_user
                 Setting.default_language = 'en'
                 assert_difference 'User.count' do
                   issue = submit_email(
                             'ticket_by_unknown_user.eml',
                             :issue => {:project => 'ecookbook'},
                             :unknown_user => 'create'
                           )
                   assert issue.is_a?(Issue)
                   assert issue.author.active?
                   assert_equal 'john.doe@somenet.foo', issue.author.mail
                   assert_equal 'John', issue.author.firstname
                   assert_equal 'Doe', issue.author.lastname
                   # account information
                   email = ActionMailer::Base.deliveries.first
                   assert_not_nil email
                   assert email.subject.include?('account activation')
                   login = mail_body(email).match(/\* Login: (.*)$/)[1].strip
                   password = mail_body(email).match(/\* Password: (.*)$/)[1].strip
                   assert_equal issue.author, User.try_to_login(login, password)
                 end
               end
               def test_add_issue_without_from_header
                 Role.anonymous.add_permission!(:add_issues)
                 assert_equal false, submit_email('ticket_without_from_header.eml')
               end
               def test_add_issue_with_invalid_attributes
                 issue = submit_email(
                           'ticket_with_invalid_attributes.eml',
                           :allow_override => 'tracker,category,priority'
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_nil issue.assigned_to
                 assert_nil issue.start_date
                 assert_nil issue.due_date
                 assert_equal 0, issue.done_ratio
                 assert_equal 'Normal', issue.priority.to_s
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
               end
               def test_add_issue_with_localized_attributes
                 User.find_by_mail('jsmith@somenet.foo').update_attribute 'language', 'fr'
                 issue = submit_email(
                           'ticket_with_localized_attributes.eml',
                           :allow_override => 'tracker,category,priority'
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket on a given project', issue.subject
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal Project.find(2), issue.project
                 assert_equal 'Feature request', issue.tracker.to_s
                 assert_equal 'Stock management', issue.category.to_s
                 assert_equal 'Urgent', issue.priority.to_s
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
               end
               def test_add_issue_with_japanese_keywords
                 ja_dev = "\xe9\x96\x8b\xe7\x99\xba"
                 ja_dev.force_encoding('UTF-8') if ja_dev.respond_to?(:force_encoding)
                 tracker = Tracker.create!(:name => ja_dev)
                 Project.find(1).trackers << tracker
                 issue = submit_email(
                           'japanese_keywords_iso_2022_jp.eml',
                           :issue => {:project => 'ecookbook'},
                           :allow_override => 'tracker'
                         )
                 assert_kind_of Issue, issue
                 assert_equal tracker, issue.tracker
               end
               def test_add_issue_from_apple_mail
                 issue = submit_email(
                           'apple_mail_with_attachment.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.attachments.size
                 attachment = issue.attachments.first
                 assert_equal 'paella.jpg', attachment.filename
                 assert_equal 10790, attachment.filesize
                 assert File.exist?(attachment.diskfile)
                 assert_equal 10790, File.size(attachment.diskfile)
                 assert_equal 'caaf384198bcbc9563ab5c058acd73cd', attachment.digest
               end
+              def test_thunderbird_with_attachment_ja
+                issue = submit_email(
+                          'thunderbird_with_attachment_ja.eml',
+                          :issue => {:project => 'ecookbook'}
+                        )
+                assert_kind_of Issue, issue
+                assert_equal 1, issue.attachments.size
+                ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
+                ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
+                attachment = issue.attachments.first
+                assert_equal ja, attachment.filename
+                assert_equal 5, attachment.filesize
+                assert File.exist?(attachment.diskfile)
+                assert_equal 5, File.size(attachment.diskfile)
+                assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
+              end
+              def test_gmail_with_attachment_ja
+                issue = submit_email(
+                          'gmail_with_attachment_ja.eml',
+                          :issue => {:project => 'ecookbook'}
+                        )
+                assert_kind_of Issue, issue
+                assert_equal 1, issue.attachments.size
+                ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88.txt"
+                ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
+                attachment = issue.attachments.first
+                assert_equal ja, attachment.filename
+                assert_equal 5, attachment.filesize
+                assert File.exist?(attachment.diskfile)
+                assert_equal 5, File.size(attachment.diskfile)
+                assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
+              end
+              def test_thunderbird_with_attachment_latin1
+                issue = submit_email(
+                          'thunderbird_with_attachment_iso-8859-1.eml',
+                          :issue => {:project => 'ecookbook'}
+                        )
+                assert_kind_of Issue, issue
+                assert_equal 1, issue.attachments.size
+                u = ""
+                u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
+                u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
+                u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
+.times { u << u1 }
+                attachment = issue.attachments.first
+                assert_equal "#{u}.png", attachment.filename
+                assert_equal 130, attachment.filesize
+                assert File.exist?(attachment.diskfile)
+                assert_equal 130, File.size(attachment.diskfile)
+                assert_equal '4d80e667ac37dddfe05502530f152abb', attachment.digest
+              end
+              def test_gmail_with_attachment_latin1
+                issue = submit_email(
+                          'gmail_with_attachment_iso-8859-1.eml',
+                          :issue => {:project => 'ecookbook'}
+                        )
+                assert_kind_of Issue, issue
+                assert_equal 1, issue.attachments.size
+                u = ""
+                u.force_encoding('UTF-8') if u.respond_to?(:force_encoding)
+                u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc"
+                u1.force_encoding('UTF-8') if u1.respond_to?(:force_encoding)
+.times { u << u1 }
+                attachment = issue.attachments.first
+                assert_equal "#{u}.txt", attachment.filename
+                assert_equal 5, attachment.filesize
+                assert File.exist?(attachment.diskfile)
+                assert_equal 5, File.size(attachment.diskfile)
+                assert_equal 'd8e8fca2dc0f896fd7cb4cb0031ba249', attachment.digest
+              end
               def test_add_issue_with_iso_8859_1_subject
                 issue = submit_email(
                           'subject_as_iso-8859-1.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 assert_equal 'Testmail from Webmail: ä ö ü...', issue.subject
               end
               def test_add_issue_with_japanese_subject
                 issue = submit_email(
                           'subject_japanese_1.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 ja = "\xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
                 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                 assert_equal ja, issue.subject
               end
               def test_add_issue_with_mixed_japanese_subject
                 issue = submit_email(
                           'subject_japanese_2.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 ja = "Re: \xe3\x83\x86\xe3\x82\xb9\xe3\x83\x88"
                 ja.force_encoding('UTF-8') if ja.respond_to?(:force_encoding)
                 assert_equal ja, issue.subject
               end
               def test_should_ignore_emails_from_locked_users
                 User.find(2).lock!
                 MailHandler.any_instance.expects(:dispatch).never
                 assert_no_difference 'Issue.count' do
                   assert_equal false, submit_email('ticket_on_given_project.eml')
                 end
               end
               def test_should_ignore_emails_from_emission_address
                 Role.anonymous.add_permission!(:add_issues)
                 assert_no_difference 'User.count' do
                   assert_equal false,
                                submit_email(
                                  'ticket_from_emission_address.eml',
                                  :issue => {:project => 'ecookbook'},
                                  :unknown_user => 'create'
                                )
                 end
               end
               def test_should_ignore_auto_replied_emails
                 MailHandler.any_instance.expects(:dispatch).never
                 [
                   "X-Auto-Response-Suppress: OOF",
                   "Auto-Submitted: auto-replied",
                   "Auto-Submitted: Auto-Replied",
                   "Auto-Submitted: auto-generated"
                 ].each do |header|
                   raw = IO.read(File.join(FIXTURES_PATH, 'ticket_on_given_project.eml'))
                   raw = header + "\n" + raw
                   assert_no_difference 'Issue.count' do
                     assert_equal false, MailHandler.receive(raw), "email with #{header} header was not ignored"
                   end
                 end
               end
               def test_add_issue_should_send_email_notification
                 Setting.notified_events = ['issue_added']
                 ActionMailer::Base.deliveries.clear
                 # This email contains: 'Project: onlinestore'
                 issue = submit_email('ticket_on_given_project.eml')
                 assert issue.is_a?(Issue)
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_update_issue
                 journal = submit_email('ticket_reply.eml')
                 assert journal.is_a?(Journal)
                 assert_equal User.find_by_login('jsmith'), journal.user
                 assert_equal Issue.find(2), journal.journalized
                 assert_match /This is reply/, journal.notes
                 assert_equal 'Feature request', journal.issue.tracker.name
               end
               def test_update_issue_with_attribute_changes
                 # This email contains: 'Status: Resolved'
                 journal = submit_email('ticket_reply_with_status.eml')
                 assert journal.is_a?(Journal)
                 issue = Issue.find(journal.issue.id)
                 assert_equal User.find_by_login('jsmith'), journal.user
                 assert_equal Issue.find(2), journal.journalized
                 assert_match /This is reply/, journal.notes
                 assert_equal 'Feature request', journal.issue.tracker.name
                 assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                 assert_equal '2010-01-01', issue.start_date.to_s
                 assert_equal '2010-12-31', issue.due_date.to_s
                 assert_equal User.find_by_login('jsmith'), issue.assigned_to
                 assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value
                 # keywords should be removed from the email body
                 assert !journal.notes.match(/^Status:/i)
                 assert !journal.notes.match(/^Start Date:/i)
               end
               def test_update_issue_with_attachment
                 assert_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count' do
                     assert_difference 'Attachment.count' do
                       assert_no_difference 'Issue.count' do
                         journal = submit_email('ticket_with_attachment.eml') do |raw|
                           raw.gsub! /^Subject: .*$/, 'Subject: Re: [Cookbook - Feature #2] (New) Add ingredients categories'
                         end
                       end
                     end
                   end
                 end
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal Issue.find(2), journal.journalized
                 assert_equal 1, journal.details.size
                 detail = journal.details.first
                 assert_equal 'attachment', detail.property
                 assert_equal 'Paella.jpg', detail.value
               end
               def test_update_issue_should_send_email_notification
                 ActionMailer::Base.deliveries.clear
                 journal = submit_email('ticket_reply.eml')
                 assert journal.is_a?(Journal)
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_update_issue_should_not_set_defaults
                 journal = submit_email(
                             'ticket_reply.eml',
                             :issue => {:tracker => 'Support request', :priority => 'High'}
                           )
                 assert journal.is_a?(Journal)
                 assert_match /This is reply/, journal.notes
                 assert_equal 'Feature request', journal.issue.tracker.name
                 assert_equal 'Normal', journal.issue.priority.name
               end
               def test_reply_to_a_message
                 m = submit_email('message_reply.eml')
                 assert m.is_a?(Message)
                 assert !m.new_record?
                 m.reload
                 assert_equal 'Reply via email', m.subject
                 # The email replies to message #2 which is part of the thread of message #1
                 assert_equal Message.find(1), m.parent
               end
               def test_reply_to_a_message_by_subject
                 m = submit_email('message_reply_by_subject.eml')
                 assert m.is_a?(Message)
                 assert !m.new_record?
                 m.reload
                 assert_equal 'Reply to the first post', m.subject
                 assert_equal Message.find(1), m.parent
               end
               def test_should_strip_tags_of_html_only_emails
                 issue = submit_email('ticket_html_only.eml', :issue => {:project => 'ecookbook'})
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'HTML email', issue.subject
                 assert_equal 'This is a html-only email.', issue.description
               end
               context "truncate emails based on the Setting" do
                 context "with no setting" do
                   setup do
                     Setting.mail_handler_body_delimiters = ''
                   end
                   should "add the entire email into the issue" do
                     issue = submit_email('ticket_on_given_project.eml')
                     assert_issue_created(issue)
                     assert issue.description.include?('---')
                     assert issue.description.include?('This paragraph is after the delimiter')
                   end
                 end
                 context "with a single string" do
                   setup do
                     Setting.mail_handler_body_delimiters = '---'
                   end
                   should "truncate the email at the delimiter for the issue" do
                     issue = submit_email('ticket_on_given_project.eml')
                     assert_issue_created(issue)
                     assert issue.description.include?('This paragraph is before delimiters')
                     assert issue.description.include?('--- This line starts with a delimiter')
                     assert !issue.description.match(/^---$/)
                     assert !issue.description.include?('This paragraph is after the delimiter')
                   end
                 end
                 context "with a single quoted reply (e.g. reply to a Redmine email notification)" do
                   setup do
                     Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
                   end
                   should "truncate the email at the delimiter with the quoted reply symbols (>)" do
                     journal = submit_email('issue_update_with_quoted_reply_above.eml')
                     assert journal.is_a?(Journal)
                     assert journal.notes.include?('An update to the issue by the sender.')
                     assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
                     assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                   end
                 end
                 context "with multiple quoted replies (e.g. reply to a reply of a Redmine email notification)" do
                   setup do
                     Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
                   end
                   should "truncate the email at the delimiter with the quoted reply symbols (>)" do
                     journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')
                     assert journal.is_a?(Journal)
                     assert journal.notes.include?('An update to the issue by the sender.')
                     assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
                     assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                   end
                 end
                 context "with multiple strings" do
                   setup do
                     Setting.mail_handler_body_delimiters = "---\nBREAK"
                   end
                   should "truncate the email at the first delimiter found (BREAK)" do
                     issue = submit_email('ticket_on_given_project.eml')
                     assert_issue_created(issue)
                     assert issue.description.include?('This paragraph is before delimiters')
                     assert !issue.description.include?('BREAK')
                     assert !issue.description.include?('This paragraph is between delimiters')
                     assert !issue.description.match(/^---$/)
                     assert !issue.description.include?('This paragraph is after the delimiter')
                   end
                 end
               end
               def test_email_with_long_subject_line
                 issue = submit_email('ticket_with_long_subject.eml')
                 assert issue.is_a?(Issue)
                 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]
               end
               def test_new_user_from_attributes_should_return_valid_user
                 to_test = {
                   # [address, name] => [login, firstname, lastname]
                   ['jsmith@example.net', nil] => ['jsmith@example.net', 'jsmith', '-'],
                   ['jsmith@example.net', 'John'] => ['jsmith@example.net', 'John', '-'],
                   ['jsmith@example.net', 'John Smith'] => ['jsmith@example.net', 'John', 'Smith'],
                   ['jsmith@example.net', 'John Paul Smith'] => ['jsmith@example.net', 'John', 'Paul Smith'],
                   ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsTheMaximumLength Smith'] => ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsT', 'Smith'],
                   ['jsmith@example.net', 'John AVeryLongLastnameThatExceedsTheMaximumLength'] => ['jsmith@example.net', 'John', 'AVeryLongLastnameThatExceedsTh']
                 }
                 to_test.each do |attrs, expected|
                   user = MailHandler.new_user_from_attributes(attrs.first, attrs.last)
                   assert user.valid?, user.errors.full_messages.to_s
                   assert_equal attrs.first, user.mail
                   assert_equal expected[0], user.login
                   assert_equal expected[1], user.firstname
                   assert_equal expected[2], user.lastname
                 end
               end
               def test_new_user_from_attributes_should_respect_minimum_password_length
                 with_settings :password_min_length => 15 do
                   user = MailHandler.new_user_from_attributes('jsmith@example.net')
                   assert user.valid?
                   assert user.password.length >= 15
                 end
               end
               def test_new_user_from_attributes_should_use_default_login_if_invalid
                 user = MailHandler.new_user_from_attributes('foo+bar@example.net')
                 assert user.valid?
                 assert user.login =~ /^user[a-f0-9]+$/
                 assert_equal 'foo+bar@example.net', user.mail
               end
               def test_new_user_with_utf8_encoded_fullname_should_be_decoded
                 assert_difference 'User.count' do
                   issue = submit_email(
                             'fullname_of_sender_as_utf8_encoded.eml',
                             :issue => {:project => 'ecookbook'},
                             :unknown_user => 'create'
                           )
                 end
                 user = User.first(:order => 'id DESC')
                 assert_equal "foo@example.org", user.mail
                 str1 = "\xc3\x84\xc3\xa4"
                 str2 = "\xc3\x96\xc3\xb6"
                 str1.force_encoding('UTF-8') if str1.respond_to?(:force_encoding)
                 str2.force_encoding('UTF-8') if str2.respond_to?(:force_encoding)
                 assert_equal str1, user.firstname
                 assert_equal str2, user.lastname
               end
               private
               def submit_email(filename, options={})
                 raw = IO.read(File.join(FIXTURES_PATH, filename))
                 yield raw if block_given?
                 MailHandler.receive(raw, options)
               end
               def assert_issue_created(issue)
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages