jro_apps/redmine Commit - r15184:11b7b573df3d

Merged r15547 and r15561 (#23020)....

Jean-Philippe Lang -

r15184:11b7b573df3d

parent child

Context file:

r15184:11b7b573df3d

Collapse all files

app/models/mail_handler.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2016  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, :handler_options
               def self.receive(raw_mail, options={})
                 options = options.deep_dup
                 options[:issue] ||= {}
                 options[:allow_override] ||= []
                 if options[:allow_override].is_a?(String)
                   options[:allow_override] = options[:allow_override].split(',')
                 end
                 options[:allow_override].map! {|s| s.strip.downcase.gsub(/\s+/, '_')}
                 # Project needs to be overridable if not specified
                 options[:allow_override] << 'project' unless options[:issue].has_key?(:project)
                 options[:no_account_notice] = (options[:no_account_notice].to_s == '1')
                 options[:no_notification] = (options[:no_notification].to_s == '1')
                 options[:no_permission_check] = (options[:no_permission_check].to_s == '1')
                 raw_mail.force_encoding('ASCII-8BIT')
                 ActiveSupport::Notifications.instrument("receive.action_mailer") do |payload|
                   mail = Mail.new(raw_mail)
                   set_payload_for_mail(payload, mail)
                   new.receive(mail, options)
                 end
               end
               # Receives an email and rescues any exception
               def self.safe_receive(*args)
                 receive(*args)
               rescue Exception => e
                 logger.error "MailHandler: an unexpected error occurred when receiving email: #{e.message}" if logger
                 return false
               end
               # Extracts MailHandler options from environment variables
               # Use when receiving emails with rake tasks
               def self.extract_options_from_env(env)
                 options = {:issue => {}}
-                %w(project status tracker category priority fixed_version).each do |option|
+                %w(project status tracker category priority assigned_to fixed_version).each do |option|
                   options[:issue][option.to_sym] = env[option] if env[option]
                 end
                 %w(allow_override unknown_user no_permission_check no_account_notice default_group project_from_subaddress).each do |option|
                   options[option.to_sym] = env[option] if env[option]
                 end
                 if env['private']
                   options[:issue][:is_private] = '1'
                 end
                 options
               end
               def logger
                 Rails.logger
               end
               cattr_accessor :ignored_emails_headers
               self.ignored_emails_headers = {
                 'Auto-Submitted' => /\Aauto-(replied|generated)/,
                 'X-Autoreply' => 'yes'
               }
               # Processes incoming emails
               # Returns the created object (eg. an issue, a message) or false
               def receive(email, options={})
                 @email = email
                 @handler_options = options
                 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.casecmp(Setting.mail_from.to_s.strip) == 0
                   if logger
                     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 "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  "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 "MailHandler: [#{@user.login}] account created"
                       end
                       add_user_to_group(handler_options[:default_group])
                       unless handler_options[:no_account_notice]
                         Mailer.account_information(@user, @user.password).deliver
                       end
                     else
                       if logger
                         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  "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+(\.[a-f0-9]+)?@}
               ISSUE_REPLY_SUBJECT_RE = %r{\[(?:[^\]]*\s+)?#(\d+)\]}
               MESSAGE_REPLY_SUBJECT_RE = %r{\[[^\]]*msg(\d+)\]}
               def dispatch
                 headers = [email.in_reply_to, email.references].flatten.compact
                 subject = email.subject.to_s
                 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 = subject.match(ISSUE_REPLY_SUBJECT_RE)
                   receive_issue_reply(m[1].to_i)
                 elsif m = 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 "MailHandler: #{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)
                 attributes = issue_attributes_from_keywords(issue)
                 if handler_options[:no_permission_check]
                   issue.tracker_id = attributes['tracker_id']
                   if project
                     issue.tracker_id ||= project.trackers.first.try(:id)
                   end
                 end
                 issue.safe_attributes = attributes
                 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
                 issue.start_date ||= User.current.today if Setting.default_issue_start_date_to_creation_date?
                 issue.is_private = (handler_options[:issue][:is_private] == '1')
                 # 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
                 issue
               end
               # Adds a note to an existing issue
               def receive_issue_reply(issue_id, from_journal=nil)
                 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)
                 if from_journal && from_journal.private_notes?
                   # If the received email was a reply to a private note, make the added note private
                   issue.private_notes = true
                 end
                 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 To and Cc as watchers before saving so the watchers can reply to Redmine
                 add_watchers(issue)
                 add_attachments(issue)
                 issue.save!
                 if logger
                   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, journal)
                 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 "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|
                     next unless accept_attachment?(attachment)
                     obj.attachments << Attachment.create(:container => obj,
                                       :file => attachment.body.decoded,
                                       :filename => attachment.filename,
                                       :author => user,
                                       :content_type => attachment.mime_type)
                   end
                 end
               end
               # Returns false if the +attachment+ of the incoming email should be ignored
               def accept_attachment?(attachment)
                 @excluded ||= Setting.mail_handler_excluded_filenames.to_s.split(',').map(&:strip).reject(&:blank?)
                 @excluded.each do |pattern|
                   regexp = %r{\A#{Regexp.escape(pattern).gsub("\\*", ".*")}\z}i
                   if attachment.filename.to_s =~ regexp
                     logger.info "MailHandler: ignoring attachment #{attachment.filename} matching #{pattern}"
                     return false
                   end
                 end
                 true
               end
               # Adds To and Cc as watchers of the given object if the sender has the
               # appropriate permission
               def add_watchers(obj)
                 if handler_options[:no_permission_check] || 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?
                     users = User.active.having_mail(addresses).to_a
                     users -= obj.watcher_users
                     users.each do |u|
                       obj.add_watcher(u)
                     end
                   end
                 end
               end
               def get_keyword(attr, options={})
                 @keywords ||= {}
                 if @keywords.has_key?(attr)
                   @keywords[attr]
                 else
                   @keywords[attr] = begin
                     override = options.key?(:override) ?
                       options[:override] :
                       (handler_options[:allow_override] & [attr.to_s.downcase.gsub(/\s+/, '_'), 'all']).present?
                     if override && (v = extract_keyword!(cleaned_up_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.sub!(regexp, '')
                 end
                 keyword
               end
               def get_project_from_receiver_addresses
                 local, domain = handler_options[:project_from_subaddress].to_s.split("@")
                 return nil unless local && domain
                 local = Regexp.escape(local)
                 [:to, :cc, :bcc].each do |field|
                   header = @email[field]
                   next if header.blank? || header.field.blank? || !header.field.respond_to?(:addrs)
                   header.field.addrs.each do |addr|
                     if addr.domain.to_s.casecmp(domain)==0 && addr.local.to_s =~ /\A#{local}\+([^+]+)\z/
                       if project = Project.find_by_identifier($1)
                         return project
                       end
                     end
                   end
                 end
                 nil
               end
               def target_project
                 # TODO: other ways to specify project:
                 # * parse the email To field
                 # * specific project (eg. Setting.mail_handler_target_project)
                 target = get_project_from_receiver_addresses
                 target ||= Project.find_by_identifier(get_keyword(:project))
                 if target.nil?
                   # Invalid project keyword, use the project specified as the default one
                   default_project = handler_options[:issue][:project]
                   if default_project.present?
                     target = Project.find_by_identifier(default_project)
                   end
                 end
                 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)
                 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' => (k = get_keyword(:assigned_to)) && find_assignee_from_keyword(k, issue).try(:id),
                   'fixed_version_id' => (k = get_keyword(:fixed_version)) && issue.project.shared_versions.named(k).first.try(:id),
                   'start_date' => get_keyword(:start_date, :format => '\d{4}-\d{2}-\d{2}'),
                   'due_date' => get_keyword(:due_date, :format => '\d{4}-\d{2}-\d{2}'),
                   'estimated_hours' => get_keyword(:estimated_hours),
                   'done_ratio' => get_keyword(:done_ratio, :format => '(\d|10)?0')
                 }.delete_if {|k, v| v.blank? }
                 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)
                     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?
                 parts = if (text_parts = email.all_parts.select {|p| p.mime_type == 'text/plain'}).present?
                           text_parts
                         elsif (html_parts = email.all_parts.select {|p| p.mime_type == 'text/html'}).present?
                           html_parts
                         else
                           [email]
                         end
                 parts.reject! do |part|
                   part.attachment?
                 end
                 @plain_text_body = parts.map do |p|
                   body_charset = Mail::RubyVer.respond_to?(:pick_encoding) ?
                                    Mail::RubyVer.pick_encoding(p.charset).to_s : p.charset
                   body = Redmine::CodesetUtil.to_utf8(p.body.decoded, body_charset)
                   # convert html parts to text
                   p.mime_type == 'text/html' ? self.class.html_body_to_text(body) : self.class.plain_text_body_to_text(body)
                 end.join("\r\n")
                 @plain_text_body
               end
               def cleaned_up_text_body
                 @cleaned_up_text_body ||= cleanup_body(plain_text_body)
               end
               def cleaned_up_subject
                 subject = email.subject.to_s
                 subject.strip[0,255]
               end
               # Converts a HTML email body to text
               def self.html_body_to_text(html)
                 Redmine::WikiFormatting.html_parser.to_text(html)
               end
               # Converts a plain/text email body to text
               def self.plain_text_body_to_text(text)
                 # Removes leading spaces that would cause the line to be rendered as
                 # preformatted text with textile
                 text.gsub(/^ +(?![*#])/, '')
               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, 30)
                 assign_string_attribute_with_limit(user, 'lastname', names.join(' '), 30)
                 user.lastname = '-' if user.lastname.blank?
                 user.language = Setting.default_language
                 user.generate_password = true
                 user.mail_notification = 'only_my_events'
                 unless user.valid?
                   user.login = "user#{Redmine::Utils.random_hex(6)}" unless user.errors[:login].blank?
                   user.firstname = "-" unless user.errors[:firstname].blank?
                   (puts user.errors[:lastname];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 handler_options[:no_notification]
                     user.mail_notification = 'none'
                   end
                   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
               # Adds the newly created user to default group
               def add_user_to_group(default_group)
                 if default_group.present?
                   default_group.split(',').each do |group_name|
                     if group = Group.named(group_name).first
                       group.users << @user
                     elsif logger
                       logger.warn "MailHandler: could not add user to [#{group_name}], group not found"
                     end
                   end
                 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)
                 Principal.detect_by_keyword(issue.assignable_users, keyword)
               end
             end

app/views/mail_handler/new.html.erb +2 0

             <!DOCTYPE html>
             <html>
             <head>
             <meta charset="utf-8" />
             <style>
               label {display:block;margin:0.5em;}
             </style>
             </head>
             <body>
             <h1>Redmine Mail Handler</h1>
             <%= form_tag({}, :multipart => true, :action => 'post') do %>
               <%= hidden_field_tag 'key', params[:key] %>
               <fieldset>
                 <legend>Raw Email</legend>
                 <%= text_area_tag 'email', '', :style => 'width:95%; height:400px;' %></label>
               </fieldset>
               <fieldset>
                 <legend>Options</legend>
                 <label>unknown_user: <%= select_tag 'unknown_user', options_for_select(['', 'ignore', 'accept', 'create']) %></label>
                 <label>default_group: <%= text_field_tag 'default_group' %></label>
                 <label>no_account_notice: <%= check_box_tag 'no_account_notice', 1 %></label>
                 <label>no_notification: <%= check_box_tag 'no_notification', 1 %></label>
                 <label>no_permission_check: <%= check_box_tag 'no_permission_check', 1 %></label>
               </fieldset>
               <fieldset>
                 <legend>Issue attributes options</legend>
                 <label>project: <%= text_field_tag 'issue[project]' %></label>
                 <label>status: <%= text_field_tag 'issue[status]' %></label>
                 <label>tracker: <%= text_field_tag 'issue[tracker]' %></label>
                 <label>category: <%= text_field_tag 'issue[category]' %></label>
                 <label>priority: <%= text_field_tag 'issue[priority]' %></label>
+                <label>assigned_to: <%= text_field_tag 'issue[assigned_to]' %></label>
+                <label>fixed_version: <%= text_field_tag 'issue[fixed_version]' %></label>
                 <label>private: <%= check_box_tag 'issue[private]', 1 %></label>
                 <label>allow_override: <%= text_field_tag 'allow_override' %></label>
               </fieldset>
               <p><%= submit_tag 'Submit Email' %></p>
             <% end %>
             </body>
             </html>

extra/mail_handler/rdm-mailhandler.rb +1 0

             #!/usr/bin/env ruby
             # Redmine - project management software
             # Copyright (C) 2006-2016  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 'net/http'
             require 'net/https'
             require 'uri'
             require 'optparse'
             module Net
               class HTTPS < HTTP
                 def self.post_form(url, params, headers, options={})
                   request = Post.new(url.path)
                   request.form_data = params
                   request.initialize_http_header(headers)
                   request.basic_auth url.user, url.password if url.user
                   http = new(url.host, url.port)
                   http.use_ssl = (url.scheme == 'https')
                   if options[:certificate_bundle]
                     http.ca_file = options[:certificate_bundle]
                   end
                   if options[:no_check_certificate]
                     http.verify_mode = OpenSSL::SSL::VERIFY_NONE
                   end
                   http.start {|h| h.request(request) }
                 end
               end
             end
             class RedmineMailHandler
               VERSION = '0.2.3'
               attr_accessor :verbose, :issue_attributes, :allow_override, :unknown_user, :default_group, :no_permission_check,
                 :url, :key, :no_check_certificate, :certificate_bundle, :no_account_notice, :no_notification, :project_from_subaddress
               def initialize
                 self.issue_attributes = {}
                 optparse = OptionParser.new do |opts|
                   opts.banner = "Usage: rdm-mailhandler.rb [options] --url=<Redmine URL> --key=<API key>"
                   opts.separator("")
                   opts.separator("Reads an email from standard input and forwards it to a Redmine server through a HTTP request.")
                   opts.separator("")
                   opts.separator("Required arguments:")
                   opts.on("-u", "--url URL",              "URL of the Redmine server") {|v| self.url = v}
                   opts.on("-k", "--key KEY",              "Redmine API key") {|v| self.key = v}
                   opts.separator("")
                   opts.separator("General options:")
                   opts.on("--key-file FILE",              "full path to a file that contains your Redmine",
                                                           "API key (use this option instead of --key if",
                                                           "you don't want the key to appear in the command",
                                                           "line)") {|v| read_key_from_file(v)}
                   opts.on("--no-check-certificate",       "do not check server certificate") {self.no_check_certificate = true}
                   opts.on("--certificate-bundle FILE",    "certificate bundle to use") {|v| self.certificate_bundle = v}
                   opts.on("-h", "--help",                 "show this help") {puts opts; exit 1}
                   opts.on("-v", "--verbose",              "show extra information") {self.verbose = true}
                   opts.on("-V", "--version",              "show version information and exit") {puts VERSION; exit}
                   opts.separator("")
                   opts.separator("User and permissions options:")
                   opts.on("--unknown-user ACTION",        "how to handle emails from an unknown user",
                                                           "ACTION can be one of the following values:",
                                                           "* ignore: email is ignored (default)",
                                                           "* accept: accept as anonymous user",
                                                           "* create: create a user account") {|v| self.unknown_user = v}
                   opts.on("--no-permission-check",        "disable permission checking when receiving",
                                                           "the email") {self.no_permission_check = '1'}
                   opts.on("--default-group GROUP",        "add created user to GROUP (none by default)",
                                                           "GROUP can be a comma separated list of groups") { |v| self.default_group = v}
                   opts.on("--no-account-notice",          "don't send account information to the newly",
                                                           "created user") { |v| self.no_account_notice = '1'}
                   opts.on("--no-notification",            "disable email notifications for the created",
                                                           "user") { |v| self.no_notification = '1'}
                   opts.separator("")
                   opts.separator("Issue attributes control options:")
                   opts.on(      "--project-from-subaddress ADDR", "select project from subadress of ADDR found",
                                                           "in To, Cc, Bcc headers") {|v| self.project_from_subaddress = v}
                   opts.on("-p", "--project PROJECT",      "identifier of the target project") {|v| self.issue_attributes['project'] = v}
                   opts.on("-s", "--status STATUS",        "name of the target status") {|v| self.issue_attributes['status'] = v}
                   opts.on("-t", "--tracker TRACKER",      "name of the target tracker") {|v| self.issue_attributes['tracker'] = v}
                   opts.on(      "--category CATEGORY",    "name of the target category") {|v| self.issue_attributes['category'] = v}
                   opts.on(      "--priority PRIORITY",    "name of the target priority") {|v| self.issue_attributes['priority'] = v}
+                  opts.on(      "--assigned-to ASSIGNEE", "assignee (username or group name)") {|v| self.issue_attributes['assigned_to'] = v}
                   opts.on(      "--fixed-version VERSION","name of the target version") {|v| self.issue_attributes['fixed_version'] = v}
                   opts.on(      "--private",              "create new issues as private") {|v| self.issue_attributes['is_private'] = '1'}
                   opts.on("-o", "--allow-override ATTRS", "allow email content to set attributes values",
                                                           "ATTRS is a comma separated list of attributes",
                                                           "or 'all' to allow all attributes to be",
                                                           "overridable (see below for details)") {|v| self.allow_override = v}
                   opts.separator <<-END_DESC
             Overrides:
               ATTRS is a comma separated list of attributes among:
               * project, tracker, status, priority, category, assigned_to, fixed_version,
                 start_date, due_date, estimated_hours, done_ratio
               * custom fields names with underscores instead of spaces (case insensitive)
               Example: --allow_override=project,priority,my_custom_field
               If the --project option is not set, project is overridable by default for
               emails that create new issues.
               You can use --allow_override=all to allow all attributes to be overridable.
             Examples:
               No project specified, emails MUST contain the 'Project' keyword, otherwise
               they will be dropped (not recommanded):
                 rdm-mailhandler.rb --url http://redmine.domain.foo --key secret
               Fixed project and default tracker specified, but emails can override
               both tracker and priority attributes using keywords:
                 rdm-mailhandler.rb --url https://domain.foo/redmine --key secret \\
                   --project myproject \\
                   --tracker bug \\
                   --allow-override tracker,priority
               Project selected by subaddress of redmine@example.net. Sending the email
               to redmine+myproject@example.net will add the issue to myproject:
                 rdm-mailhandler.rb --url http://redmine.domain.foo --key secret \\
                   --project-from-subaddress redmine@example.net
             END_DESC
                   opts.summary_width = 27
                 end
                 optparse.parse!
                 unless url && key
                   puts "Some arguments are missing. Use `rdm-mailhandler.rb --help` for getting help."
                   exit 1
                 end
               end
               def submit(email)
                 uri = url.gsub(%r{/*$}, '') + '/mail_handler'
                 headers = { 'User-Agent' => "Redmine mail handler/#{VERSION}" }
                 data = { 'key' => key, 'email' => email,
                                        'allow_override' => allow_override,
                                        'unknown_user' => unknown_user,
                                        'default_group' => default_group,
                                        'no_account_notice' => no_account_notice,
                                        'no_notification' => no_notification,
                                        'no_permission_check' => no_permission_check,
                                        'project_from_subaddress' => project_from_subaddress}
                 issue_attributes.each { |attr, value| data["issue[#{attr}]"] = value }
                 debug "Posting to #{uri}..."
                 begin
                   response = Net::HTTPS.post_form(URI.parse(uri), data, headers, :no_check_certificate => no_check_certificate, :certificate_bundle => certificate_bundle)
                 rescue SystemCallError, IOError => e # connection refused, etc.
                   warn "An error occured while contacting your Redmine server: #{e.message}"
                   return 75 # temporary failure
                 end
                 debug "Response received: #{response.code}"
                 case response.code.to_i
                   when 403
                     warn "Request was denied by your Redmine server. " +
                          "Make sure that 'WS for incoming emails' is enabled in application settings and that you provided the correct API key."
                     return 77
                   when 422
                     warn "Request was denied by your Redmine server. " +
                          "Possible reasons: email is sent from an invalid email address or is missing some information."
                     return 77
                   when 400..499
                     warn "Request was denied by your Redmine server (#{response.code})."
                     return 77
                   when 500..599
                     warn "Failed to contact your Redmine server (#{response.code})."
                     return 75
                   when 201
                     debug "Proccessed successfully"
                     return 0
                   else
                     return 1
                 end
               end
               private
               def debug(msg)
                 puts msg if verbose
               end
               def read_key_from_file(filename)
                 begin
                   self.key = File.read(filename).strip
                 rescue Exception => e
                   $stderr.puts "Unable to read the key from #{filename}:\n#{e.message}"
                   exit 1
                 end
               end
             end
             handler = RedmineMailHandler.new
             exit(handler.submit(STDIN.read))

lib/tasks/email.rake +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2016  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.
             namespace :redmine do
               namespace :email do
                 desc <<-END_DESC
             Read an email from standard input.
             See redmine:email:receive_imap for more options and examples.
             END_DESC
                 task :read => :environment do
                   Mailer.with_synched_deliveries do
                     MailHandler.receive(STDIN.read, MailHandler.extract_options_from_env(ENV))
                   end
                 end
                 desc <<-END_DESC
             Read emails from an IMAP server.
             Available IMAP options:
               host=HOST                IMAP server host (default: 127.0.0.1)
               port=PORT                IMAP server port (default: 143)
               ssl=SSL                  Use SSL/TLS? (default: false)
               starttls=STARTTLS        Use STARTTLS? (default: false)
               username=USERNAME        IMAP account
               password=PASSWORD        IMAP password
               folder=FOLDER            IMAP folder to read (default: INBOX)
             Processed emails control options:
               move_on_success=MAILBOX  move emails that were successfully received
                                        to MAILBOX instead of deleting them
               move_on_failure=MAILBOX  move emails that were ignored to MAILBOX
             User and permissions options:
               unknown_user=ACTION      how to handle emails from an unknown user
                                        ACTION can be one of the following values:
                                        ignore: email is ignored (default)
                                        accept: accept as anonymous user
                                        create: create a user account
               no_permission_check=1    disable permission checking when receiving
                                        the email
               no_account_notice=1      disable new user account notification
               default_group=foo,bar    adds created user to foo and bar groups
             Issue attributes control options:
               project=PROJECT          identifier of the target project
               status=STATUS            name of the target status
               tracker=TRACKER          name of the target tracker
               category=CATEGORY        name of the target category
               priority=PRIORITY        name of the target priority
+              assigned_to=ASSIGNEE     assignee (username or group name)
               fixed_version=VERSION    name of the target version
               private                  create new issues as private
               allow_override=ATTRS     allow email content to set attributes values
                                        ATTRS is a comma separated list of attributes
                                        or 'all' to allow all attributes to be overridable
                                        (see below for details)
             Overrides:
               ATTRS is a comma separated list of attributes among:
               * project, tracker, status, priority, category, assigned_to, fixed_version,
                 start_date, due_date, estimated_hours, done_ratio
               * custom fields names with underscores instead of spaces (case insensitive)
               Example: allow_override=project,priority,my_custom_field
               If the project option is not set, project is overridable by default for
               emails that create new issues.
               You can use allow_override=all to allow all attributes to be overridable.
             Examples:
               # No project specified. Emails MUST contain the 'Project' keyword:
               rake redmine:email:receive_imap RAILS_ENV="production" \\
                 host=imap.foo.bar username=redmine@example.net password=xxx
               # Fixed project and default tracker specified, but emails can override
               # both tracker and priority attributes:
               rake redmine:email:receive_imap RAILS_ENV="production" \\
                 host=imap.foo.bar username=redmine@example.net password=xxx ssl=1 \\
                 project=foo \\
                 tracker=bug \\
                 allow_override=tracker,priority
             END_DESC
                 task :receive_imap => :environment do
                   imap_options = {:host => ENV['host'],
                                   :port => ENV['port'],
                                   :ssl => ENV['ssl'],
                                   :starttls => ENV['starttls'],
                                   :username => ENV['username'],
                                   :password => ENV['password'],
                                   :folder => ENV['folder'],
                                   :move_on_success => ENV['move_on_success'],
                                   :move_on_failure => ENV['move_on_failure']}
                   Mailer.with_synched_deliveries do
                     Redmine::IMAP.check(imap_options, MailHandler.extract_options_from_env(ENV))
                   end
                 end
                 desc <<-END_DESC
             Read emails from an POP3 server.
             Available POP3 options:
               host=HOST                POP3 server host (default: 127.0.0.1)
               port=PORT                POP3 server port (default: 110)
               username=USERNAME        POP3 account
               password=PASSWORD        POP3 password
               apop=1                   use APOP authentication (default: false)
               ssl=SSL                  Use SSL? (default: false)
               delete_unprocessed=1     delete messages that could not be processed
                                        successfully from the server (default
                                        behaviour is to leave them on the server)
             See redmine:email:receive_imap for more options and examples.
             END_DESC
                 task :receive_pop3 => :environment do
                   pop_options  = {:host => ENV['host'],
                                   :port => ENV['port'],
                                   :apop => ENV['apop'],
                                   :ssl => ENV['ssl'],
                                   :username => ENV['username'],
                                   :password => ENV['password'],
                                   :delete_unprocessed => ENV['delete_unprocessed']}
                   Mailer.with_synched_deliveries do
                     Redmine::POP3.check(pop_options, MailHandler.extract_options_from_env(ENV))
                   end
                 end
                 desc "Send a test email to the user with the provided login name"
                 task :test, [:login] => :environment do |task, args|
                   include Redmine::I18n
                   abort l(:notice_email_error, "Please include the user login to test with. Example: rake redmine:email:test[login]") if args[:login].blank?
                   user = User.find_by_login(args[:login])
                   abort l(:notice_email_error, "User #{args[:login]} not found") unless user && user.logged?
                   ActionMailer::Base.raise_delivery_errors = true
                   begin
                     Mailer.with_synched_deliveries do
                       Mailer.test_email(user).deliver
                     end
                     puts l(:notice_email_sent, user.mail)
                   rescue Exception => e
                     abort l(:notice_email_error, e.message)
                   end
                 end
               end
             end

test/unit/mail_handler_test.rb +11 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2016  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,
                        :email_addresses, :user_preferences,
                        :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_with_specific_overrides
                 issue = submit_email('ticket_on_given_project.eml',
                   :allow_override => ['status', 'start_date', 'due_date', 'assigned_to', 'fixed_version', 'estimated_hours', 'done_ratio']
                 )
                 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
                 # 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)
               end
               def test_add_issue_with_all_overrides
                 issue = submit_email('ticket_on_given_project.eml', :allow_override => 'all')
                 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 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
               end
               def test_add_issue_without_overrides_should_ignore_attributes
                 WorkflowRule.delete_all
                 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 'New ticket on a given project', issue.subject
                 assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                 assert_equal User.find_by_login('jsmith'), issue.author
                 assert_equal issue.project.trackers.first, issue.tracker
                 assert_equal 'New', issue.status.name
                 assert_not_equal '2010-01-01', issue.start_date.to_s
                 assert_nil issue.due_date
                 assert_nil issue.assigned_to
                 assert_nil issue.fixed_version
                 assert_nil issue.estimated_hours
                 assert_equal 0, issue.done_ratio
               end
               def test_add_issue_to_project_specified_by_subaddress
                 # This email has redmine+onlinestore@somenet.foo as 'To' header
                 issue = submit_email(
                           'ticket_on_project_given_by_to_header.eml',
                           :issue => {:tracker => 'Support request'},
                           :project_from_subaddress => 'redmine@somenet.foo'
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'onlinestore', issue.project.identifier
                 assert_equal 'Support request', issue.tracker.name
               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_default_version
                 # This email contains: 'Project: onlinestore'
                 issue = submit_email(
                           'ticket_on_given_project.eml',
                           :issue => {:fixed_version => 'Alpha'}
                         )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 assert_equal 'Alpha', issue.reload.fixed_version.name
               end
+              def test_add_issue_with_default_assigned_to
+                # This email contains: 'Project: onlinestore'
+                issue = submit_email(
+                          'ticket_on_given_project.eml',
+                          :issue => {:assigned_to => 'jsmith'}
+                        )
+                assert issue.is_a?(Issue)
+                assert !issue.new_record?
+                assert_equal 'jsmith', issue.reload.assigned_to.login
+              end
               def test_add_issue_with_status_override
                 # This email contains: 'Project: onlinestore' and 'Status: Resolved'
                 issue = submit_email('ticket_on_given_project.eml', :allow_override => ['status'])
                 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_should_accept_is_private_attribute
                 issue = submit_email('ticket_on_given_project.eml', :issue => {:is_private => '1'})
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 assert_equal true, issue.reload.is_private
               end
               def test_add_issue_with_group_assignment
                 with_settings :issue_group_assignment => '1' do
                   issue = submit_email('ticket_on_given_project.eml', :allow_override => ['assigned_to']) 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'}, :allow_override => ['database', 'Searchable_field']
                 )
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 issue.reload
                 assert_equal 'New ticket with custom field values', issue.subject
                 assert_equal 'PostgreSQL', issue.custom_field_value(1)
                 assert_equal 'Value for a custom field', issue.custom_field_value(2)
                 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'}, :allow_override => ['affected version']
                 ) 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', :allow_override => ['assigned_to']) 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_should_set_default_start_date
                 with_settings :default_issue_start_date_to_creation_date => '1' do
                   issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
                   assert issue.is_a?(Issue)
                   assert_equal Date.today, issue.start_date
                 end
               end
               def test_add_issue_should_add_cc_as_watchers
                 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_from_additional_email_address
                 user = User.find(2)
                 user.mail = 'mainaddress@somenet.foo'
                 user.save!
                 EmailAddress.create!(:user => user, :address => 'jsmith@somenet.foo')
                 issue = submit_email('ticket_on_given_project.eml')
                 assert issue
                 assert_equal user, issue.author
               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?
                   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_should_send_notification
                 issue = submit_email('ticket_on_given_project.eml', :allow_override => 'all')
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.include?("##{issue.id}")
                 assert mail.subject.include?('New ticket on a given project')
               end
               def test_created_user_should_be_added_to_groups
                 group1 = Group.generate!
                 group2 = Group.generate!
                 assert_difference 'User.count' do
                   submit_email(
                     'ticket_by_unknown_user.eml',
                     :issue => {:project => 'ecookbook'},
                     :unknown_user => 'create',
                     :default_group => "#{group1.name},#{group2.name}"
                   )
                 end
                 user = User.order('id DESC').first
                 assert_equal [group1, group2].sort, user.groups.sort
               end
               def test_created_user_should_not_receive_account_information_with_no_account_info_option
                 assert_difference 'User.count' do
                   submit_email(
                     'ticket_by_unknown_user.eml',
                     :issue => {:project => 'ecookbook'},
                     :unknown_user => 'create',
                     :no_account_notice => '1'
                   )
                 end
                 # only 1 email for the new issue notification
                 assert_equal 1, ActionMailer::Base.deliveries.size
                 email = ActionMailer::Base.deliveries.first
                 assert_include 'Ticket by unknown user', email.subject
               end
               def test_created_user_should_have_mail_notification_to_none_with_no_notification_option
                 assert_difference 'User.count' do
                   submit_email(
                     'ticket_by_unknown_user.eml',
                     :issue => {:project => 'ecookbook'},
                     :unknown_user => 'create',
                     :no_notification => '1'
                   )
                 end
                 user = User.order('id DESC').first
                 assert_equal 'none', user.mail_notification
               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
                 with_settings :default_issue_start_date_to_creation_date => '0' do
                   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
               end
               def test_add_issue_with_invalid_project_should_be_assigned_to_default_project
                 issue = submit_email('ticket_on_given_project.eml', :issue => {:project => 'ecookbook'}, :allow_override => 'project') do |email|
                   email.gsub!(/^Project:.+$/, 'Project: invalid')
                 end
                 assert issue.is_a?(Issue)
                 assert !issue.new_record?
                 assert_equal 'ecookbook', issue.project.identifier
               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".force_encoding('UTF-8')
                 tracker = Tracker.generate!(: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".force_encoding('UTF-8')
                 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".force_encoding('UTF-8')
                 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 = "".force_encoding('UTF-8')
                 u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc".force_encoding('UTF-8')
 .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 = "".force_encoding('UTF-8')
                 u1 = "\xc3\x84\xc3\xa4\xc3\x96\xc3\xb6\xc3\x9c\xc3\xbc".force_encoding('UTF-8')
 .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_mail_with_attachment_latin2
                 issue = submit_email(
                           'ticket_with_text_attachment_iso-8859-2.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.attachments.size
                 attachment = issue.attachments.first
                 assert_equal 'latin2.txt', attachment.filename
                 assert_equal 19, attachment.filesize
                 assert File.exist?(attachment.diskfile)
                 assert_equal 19, File.size(attachment.diskfile)
                 content = "p\xF8\xEDli\xB9 \xBEluou\xE8k\xFD k\xF9n".force_encoding('CP852')
                 assert_equal content, File.read(attachment.diskfile).force_encoding('CP852')
               end
               def test_multiple_inline_text_parts_should_be_appended_to_issue_description
                 issue = submit_email('multiple_text_parts.eml', :issue => {:project => 'ecookbook'})
                 assert_include 'first', issue.description
                 assert_include 'second', issue.description
                 assert_include 'third', issue.description
               end
               def test_attachment_text_part_should_be_added_as_issue_attachment
                 issue = submit_email('multiple_text_parts.eml', :issue => {:project => 'ecookbook'})
                 assert_not_include 'Plain text attachment', issue.description
                 attachment = issue.attachments.detect {|a| a.filename == 'textfile.txt'}
                 assert_not_nil attachment
                 assert_include 'Plain text attachment', File.read(attachment.diskfile)
               end
               def test_add_issue_with_iso_8859_1_subject
                 issue = submit_email(
                           'subject_as_iso-8859-1.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 str = "Testmail from Webmail: \xc3\xa4 \xc3\xb6 \xc3\xbc...".force_encoding('UTF-8')
                 assert_kind_of Issue, issue
                 assert_equal str, issue.subject
               end
               def test_quoted_printable_utf8
                 issue = submit_email(
                           'quoted_printable_utf8.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 str = "Freundliche Gr\xc3\xbcsse".force_encoding('UTF-8')
                 assert_equal str, issue.description
               end
               def test_gmail_iso8859_2
                 issue = submit_email(
                           'gmail-iso8859-2.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 str = "Na \xc5\xa1triku se su\xc5\xa1i \xc5\xa1osi\xc4\x87.".force_encoding('UTF-8')
                 assert issue.description.include?(str)
               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".force_encoding('UTF-8')
                 assert_equal ja, issue.subject
               end
               def test_add_issue_with_korean_body
                 # Make sure mail bodies with a charset unknown to Ruby
                 # but known to the Mail gem 2.5.4 are handled correctly
                 kr = "\xEA\xB3\xA0\xEB\xA7\x99\xEC\x8A\xB5\xEB\x8B\x88\xEB\x8B\xA4.".force_encoding('UTF-8')
                 issue = submit_email(
                         'body_ks_c_5601-1987.eml',
                         :issue => {:project => 'ecookbook'}
                       )
                 assert_kind_of Issue, issue
                 assert_equal kr, issue.description
               end
               def test_add_issue_with_no_subject_header
                 issue = submit_email(
                           'no_subject_header.eml',
                           :issue => {:project => 'ecookbook'}
                         )
                 assert_kind_of Issue, issue
                 assert_equal '(no subject)', 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".force_encoding('UTF-8')
                 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
                 [
                   "Auto-Submitted: auto-replied",
                   "Auto-Submitted: Auto-Replied",
                   "Auto-Submitted: auto-generated",
                   'X-Autoreply: yes'
                 ].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
               test "should not ignore Auto-Submitted headers not defined in RFC3834" do
                 [
                   "Auto-Submitted: auto-forwarded"
                 ].each do |header|
                   raw = IO.read(File.join(FIXTURES_PATH, 'ticket_on_given_project.eml'))
                   raw = header + "\n" + raw
                   assert_difference 'Issue.count', 1 do
                     assert_not_nil MailHandler.receive(raw), "email with #{header} header was ignored"
                   end
                 end
               end
               def test_add_issue_should_send_email_notification
                 Setting.notified_events = ['issue_added']
                 # 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 false, journal.private_notes
                 assert_equal 'Feature request', journal.issue.tracker.name
               end
               def test_update_issue_should_accept_issue_id_after_space_inside_brackets
                 journal = submit_email('ticket_reply_with_status.eml') do |email|
                   assert email.sub!(/^Subject:.*$/, "Subject: Re: [Feature request #2] Add ingredients categories")
                 end
                 assert journal.is_a?(Journal)
                 assert_equal Issue.find(2), journal.journalized
               end
               def test_update_issue_should_accept_issue_id_inside_brackets
                 journal = submit_email('ticket_reply_with_status.eml') do |email|
                   assert email.sub!(/^Subject:.*$/, "Subject: Re: [#2] Add ingredients categories")
                 end
                 assert journal.is_a?(Journal)
                 assert_equal Issue.find(2), journal.journalized
               end
               def test_update_issue_should_ignore_bogus_issue_ids_in_subject
                 journal = submit_email('ticket_reply_with_status.eml') do |email|
                   assert email.sub!(/^Subject:.*$/, "Subject: Re: [12345#1][bogus#1][Feature request #2] Add ingredients categories")
                 end
                 assert journal.is_a?(Journal)
                 assert_equal Issue.find(2), journal.journalized
               end
               def test_update_issue_with_attribute_changes
                 journal = submit_email('ticket_reply_with_status.eml', :allow_override => ['status','assigned_to','start_date','due_date', 'float field'])
                 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.order('id DESC').first
                 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
                 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_update_issue_should_add_cc_as_watchers
                 Watcher.delete_all
                 issue = Issue.find(2)
                 assert_difference 'Watcher.count' do
                   assert submit_email('issue_update_with_cc.eml')
                 end
                 issue.reload
                 assert_equal 1, issue.watcher_user_ids.size
                 assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
               end
               def test_update_issue_should_not_add_cc_as_watchers_if_already_watching
                 Watcher.delete_all
                 issue = Issue.find(2)
                 Watcher.create!(:watchable => issue, :user => User.find_by_mail('dlopper@somenet.foo'))
                 assert_no_difference 'Watcher.count' do
                   assert submit_email('issue_update_with_cc.eml')
                 end
               end
               def test_replying_to_a_private_note_should_add_reply_as_private
                 private_journal = Journal.create!(:notes => 'Private notes', :journalized => Issue.find(1), :private_notes => true, :user_id => 2)
                 assert_difference 'Journal.count' do
                   journal = submit_email('ticket_reply.eml') do |email|
                     email.sub! %r{^In-Reply-To:.*$}, "In-Reply-To: <redmine.journal-#{private_journal.id}.20060719210421@osiris>"
                   end
                   assert_kind_of Journal, journal
                   assert_match /This is reply/, journal.notes
                   assert_equal true, journal.private_notes
                 end
               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_convert_tags_of_html_only_emails
                 with_settings :text_formatting => 'textile' do
                   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.\r\n\r\nh1. With a title\r\n\r\nand a paragraph.", issue.description
                 end
               end
               def test_should_handle_outlook_web_access_2010_html_only
                 issue = submit_email('outlook_web_access_2010_html_only.eml', :issue => {:project => 'ecookbook'})
                 assert issue.is_a?(Issue)
                 issue.reload
                 assert_equal 'Upgrade Redmine to 3.0.x', issue.subject
                 assert_equal "A mess.\r\n\r\n--Geoff Maciolek\r\nMYCOMPANYNAME, LLC", issue.description
               end
               def test_should_handle_outlook_2010_html_only
                 issue = submit_email('outlook_2010_html_only.eml', :issue => {:project => 'ecookbook'})
                 assert issue.is_a?(Issue)
                 issue.reload
                 assert_equal 'Test email', issue.subject
                 assert_equal "Simple, unadorned test email generated by Outlook 2010. It is in HTML format, but" +
                   " no special formatting has been chosen. I’m going to save this as a draft and then manually" +
                   " drop it into the Inbox for scraping by Redmine 3.0.2.", issue.description
               end
               test "truncate emails with no setting should add the entire email into the issue" do
                 with_settings :mail_handler_body_delimiters => '' 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
               test "truncate emails with a single string should truncate the email at the delimiter for the issue" do
                 with_settings :mail_handler_body_delimiters => '---' 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
               test "truncate emails with a single quoted reply should truncate the email at the delimiter with the quoted reply symbols (>)" do
                 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' 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
               test "truncate emails with multiple quoted replies should truncate the email at the delimiter with the quoted reply symbols (>)" do
                 with_settings :mail_handler_body_delimiters => '--- Reply above. Do not remove this line. ---' 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
               test "truncate emails with multiple strings should truncate the email at the first delimiter found (BREAK)" do
                 with_settings :mail_handler_body_delimiters => "---\nBREAK" 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
               def test_attachments_that_match_mail_handler_excluded_filenames_should_be_ignored
                 with_settings :mail_handler_excluded_filenames => '*.vcf, *.jpg' do
                   issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                   assert issue.is_a?(Issue)
                   assert !issue.new_record?
                   assert_equal 0, issue.reload.attachments.size
                 end
               end
               def test_attachments_that_do_not_match_mail_handler_excluded_filenames_should_be_attached
                 with_settings :mail_handler_excluded_filenames => '*.vcf, *.gif' do
                   issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                   assert issue.is_a?(Issue)
                   assert !issue.new_record?
                   assert_equal 1, issue.reload.attachments.size
                 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_first_keyword_should_be_matched
                 issue = submit_email('ticket_with_duplicate_keyword.eml', :allow_override => 'priority')
                 assert issue.is_a?(Issue)
                 assert_equal 'High', issue.priority.name
               end
               def test_keyword_after_delimiter_should_be_ignored
                 with_settings :mail_handler_body_delimiters => "== DELIMITER ==" do
                   issue = submit_email('ticket_with_keyword_after_delimiter.eml', :allow_override => 'priority')
                   assert issue.is_a?(Issue)
                   assert_equal 'Normal', issue.priority.name
                 end
               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
                   assert_equal 'only_my_events', user.mail_notification
                 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.order('id DESC').first
                 assert_equal "foo@example.org", user.mail
                 str1 = "\xc3\x84\xc3\xa4".force_encoding('UTF-8')
                 str2 = "\xc3\x96\xc3\xb6".force_encoding('UTF-8')
                 assert_equal str1, user.firstname
                 assert_equal str2, user.lastname
               end
               def test_extract_options_from_env_should_return_options
                 options = MailHandler.extract_options_from_env({
                   'tracker' => 'defect',
                   'project' => 'foo',
                   'unknown_user' => 'create'
                 })
                 assert_equal({
                   :issue => {:tracker => 'defect', :project => 'foo'},
                   :unknown_user => 'create'
                 }, options)
               end
               def test_safe_receive_should_rescue_exceptions_and_return_false
                 MailHandler.stubs(:receive).raises(Exception.new "Something went wrong")
                 assert_equal false, MailHandler.safe_receive
               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