jro_apps/redmine Commit - r10589:d5c08680f64a

Merged r10812 from trunk (#12375)...

Toshi MARUYAMA -

r10589:d5c08680f64a

parent child

Context file:

r10589:d5c08680f64a

Collapse all files

test/fixtures/mail_handler/subject_japanese_2.eml created 644 +7 0

			@@ -0,0 +1,7
		1	From: John Smith <JSmith@somenet.foo>
		2	To: "redmine@somenet.foo" <redmine@somenet.foo>
		3	Subject: Re: =?iso-2022-jp?b?GyRCJUYlOSVIGyhCCg=?=
		4	Date: Fri, 1 Jun 2012 14:39:38 +0200
		5	Message-ID: <87C31D42249DD0489D1A1444E3232DD7019D6183@foo.bar>
		6
		7	Fixture

app/models/mail_handler.rb +2 -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|
                      obj.attachments << Attachment.create(:container => obj,
                                        :file => attachment.decoded,
                                        :filename => attachment.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]
-                       if m = h.value.match(/^=\?([^\?]+)\?/)
+                       # 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 +11 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_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