jro_apps/redmine Commit - r13827:214e737ee02c

Merged r14159 (#19558)....

Jean-Philippe Lang -

r13827:214e737ee02c

parent child

Context file:

r13827:214e737ee02c

Collapse all files

app/models/mail_handler.rb 0 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class MailHandler < ActionMailer::Base
                include ActionView::Helpers::SanitizeHelper
                include Redmine::I18n
                class UnauthorizedAction < StandardError; end
                class MissingInformation < StandardError; end
                attr_reader :email, :user
                def self.receive(email, options={})
                  @@handler_options = options.deep_dup
                  @@handler_options[:issue] ||= {}
                  if @@handler_options[:allow_override].is_a?(String)
                    @@handler_options[:allow_override] = @@handler_options[:allow_override].split(',').collect(&:strip)
                  end
                  @@handler_options[:allow_override] ||= []
                  # Project needs to be overridable if not specified
                  @@handler_options[:allow_override] << 'project' unless @@handler_options[:issue].has_key?(:project)
                  # Status overridable by default
                  @@handler_options[:allow_override] << 'status' unless @@handler_options[:issue].has_key?(:status)
                  @@handler_options[:no_account_notice] = (@@handler_options[:no_account_notice].to_s == '1')
                  @@handler_options[:no_notification] = (@@handler_options[:no_notification].to_s == '1')
                  @@handler_options[:no_permission_check] = (@@handler_options[:no_permission_check].to_s == '1')
                  email.force_encoding('ASCII-8BIT')
                  super(email)
                end
                # Receives an email and rescues any exception
                def self.safe_receive(*args)
                  receive(*args)
                rescue Exception => e
                  logger.error "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).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).each do |option|
                    options[option.to_sym] = env[option] if env[option]
                  end
                  options
                end
                def logger
                  Rails.logger
                end
                cattr_accessor :ignored_emails_headers
                @@ignored_emails_headers = {
-                 'X-Auto-Response-Suppress' => /(oof|all)/,
                  '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)
                  @email = email
                  sender_email = email.from.to_a.first.to_s.strip
                  # Ignore emails received from the application emission address to avoid hell cycles
                  if sender_email.downcase == Setting.mail_from.to_s.strip.downcase
                    if logger
                      logger.info  "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 e.message if logger
                  false
                rescue MissingInformation => e
                  logger.error "MailHandler: missing information from #{user}: #{e.message}" if logger
                  false
                rescue UnauthorizedAction => e
                  logger.error "MailHandler: unauthorized attempt from #{user}" if logger
                  false
                end
                def dispatch_to_default
                  receive_issue
                end
                # Creates a new issue
                def receive_issue
                  project = target_project
                  # check permission
                  unless @@handler_options[:no_permission_check]
                    raise UnauthorizedAction unless user.allowed_to?(:add_issues, project)
                  end
                  issue = Issue.new(:author => user, :project => project)
                  issue.safe_attributes = issue_attributes_from_keywords(issue)
                  issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
                  issue.subject = cleaned_up_subject
                  if issue.subject.blank?
                    issue.subject = '(no subject)'
                  end
                  issue.description = cleaned_up_text_body
                  issue.start_date ||= Date.today if Setting.default_issue_start_date_to_creation_date?
                  # 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_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.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 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?
                      User.active.having_mail(addresses).each do |w|
                        obj.add_watcher(w)
                      end
                    end
                  end
                end
                def get_keyword(attr, options={})
                  @keywords ||= {}
                  if @keywords.has_key?(attr)
                    @keywords[attr]
                  else
                    @keywords[attr] = begin
                      if (options[:override] || @@handler_options[:allow_override].include?(attr.to_s)) &&
                            (v = extract_keyword!(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 target_project
                  # TODO: other ways to specify project:
                  # * parse the email To field
                  # * specific project (eg. Setting.mail_handler_target_project)
                  target = Project.find_by_identifier(get_keyword(:project))
                  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)
                  assigned_to = (k = get_keyword(:assigned_to, :override => true)) && find_assignee_from_keyword(k, issue)
                  attrs = {
                    'tracker_id' => (k = get_keyword(:tracker)) && issue.project.trackers.named(k).first.try(:id),
                    'status_id' =>  (k = get_keyword(:status)) && IssueStatus.named(k).first.try(:id),
                    'priority_id' => (k = get_keyword(:priority)) && IssuePriority.named(k).first.try(:id),
                    'category_id' => (k = get_keyword(:category)) && issue.project.issue_categories.named(k).first.try(:id),
                    'assigned_to_id' => assigned_to.try(:id),
                    'fixed_version_id' => (k = get_keyword(:fixed_version, :override => true)) &&
                                              issue.project.shared_versions.named(k).first.try(:id),
                    'start_date' => get_keyword(:start_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                    'due_date' => get_keyword(:due_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                    'estimated_hours' => get_keyword(:estimated_hours, :override => true),
                    'done_ratio' => get_keyword(:done_ratio, :override => true, :format => '(\d|10)?0')
                  }.delete_if {|k, v| v.blank? }
                  if issue.new_record? && attrs['tracker_id'].nil?
                    attrs['tracker_id'] = issue.project.trackers.first.try(:id)
                  end
                  attrs
                end
                # Returns a Hash of issue custom field values extracted from keywords in the email body
                def custom_field_values_from_keywords(customized)
                  customized.custom_field_values.inject({}) do |h, v|
                    if keyword = get_keyword(v.custom_field.name, :override => true)
                      h[v.custom_field.id.to_s] = v.custom_field.value_from_keyword(keyword, customized)
                    end
                    h
                  end
                end
                # Returns the text/plain part of the email
                # If not found (eg. HTML-only email), returns the body with tags removed
                def plain_text_body
                  return @plain_text_body unless @plain_text_body.nil?
                  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
                    Redmine::CodesetUtil.to_utf8(p.body.decoded, body_charset)
                  end.join("\r\n")
                  # strip html tags and remove doctype directive
                  if parts.any? {|p| p.mime_type == 'text/html'}
                    @plain_text_body = strip_tags(@plain_text_body.strip)
                    @plain_text_body.sub! %r{^<!DOCTYPE .*$}, ''
                  end
                  @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
                def self.full_sanitizer
                  @full_sanitizer ||= HTML::FullSanitizer.new
                end
                def self.assign_string_attribute_with_limit(object, attribute, value, limit=nil)
                  limit ||= object.class.columns_hash[attribute.to_s].limit || 255
                  value = value.to_s.slice(0, limit)
                  object.send("#{attribute}=", value)
                end
                # Returns a User from an email address and a full name
                def self.new_user_from_attributes(email_address, fullname=nil)
                  user = User.new
                  # Truncating the email address would result in an invalid format
                  user.mail = email_address
                  assign_string_attribute_with_limit(user, 'login', email_address, User::LOGIN_LENGTH_LIMIT)
                  names = fullname.blank? ? email_address.gsub(/@.*$/, '').split('.') : fullname.split
                  assign_string_attribute_with_limit(user, 'firstname', names.shift, 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)
                  keyword = keyword.to_s.downcase
                  assignable = issue.assignable_users
                  assignee = nil
                  assignee ||= assignable.detect {|a|
                                 a.mail.to_s.downcase == keyword ||
                                   a.login.to_s.downcase == keyword
                               }
                  if assignee.nil? && keyword.match(/ /)
                    firstname, lastname = *(keyword.split) # "First Last Throwaway"
                    assignee ||= assignable.detect {|a|
                                   a.is_a?(User) && a.firstname.to_s.downcase == firstname &&
                                     a.lastname.to_s.downcase == lastname
                                 }
                  end
                  if assignee.nil?
                    assignee ||= assignable.detect {|a| a.name.downcase == keyword}
                  end
                  assignee
                end
              end

app/models/mailer.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 Mailer < ActionMailer::Base
                layout 'mailer'
                helper :application
                helper :issues
                helper :custom_fields
                include Redmine::I18n
                def self.default_url_options
                  options = {:protocol => Setting.protocol}
                  if Setting.host_name.to_s =~ /\A(https?\:\/\/)?(.+?)(\:(\d+))?(\/.+)?\z/i
                    host, port, prefix = $2, $4, $5
                    options.merge!({
                      :host => host, :port => port, :script_name => prefix
                    })
                  else
                    options[:host] = Setting.host_name
                  end
                  options
                end
                # Builds a mail for notifying to_users and cc_users about a new issue
                def issue_add(issue, to_users, cc_users)
                  redmine_headers 'Project' => issue.project.identifier,
                                  'Issue-Id' => issue.id,
                                  'Issue-Author' => issue.author.login
                  redmine_headers 'Issue-Assignee' => issue.assigned_to.login if issue.assigned_to
                  message_id issue
                  references issue
                  @author = issue.author
                  @issue = issue
                  @users = to_users + cc_users
                  @issue_url = url_for(:controller => 'issues', :action => 'show', :id => issue)
                  mail :to => to_users,
                    :cc => cc_users,
                    :subject => "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] (#{issue.status.name}) #{issue.subject}"
                end
                # Notifies users about a new issue
                def self.deliver_issue_add(issue)
                  to = issue.notified_users
                  cc = issue.notified_watchers - to
                  issue.each_notification(to + cc) do |users|
                    Mailer.issue_add(issue, to & users, cc & users).deliver
                  end
                end
                # Builds a mail for notifying to_users and cc_users about an issue update
                def issue_edit(journal, to_users, cc_users)
                  issue = journal.journalized
                  redmine_headers 'Project' => issue.project.identifier,
                                  'Issue-Id' => issue.id,
                                  'Issue-Author' => issue.author.login
                  redmine_headers 'Issue-Assignee' => issue.assigned_to.login if issue.assigned_to
                  message_id journal
                  references issue
                  @author = journal.user
                  s = "[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}] "
                  s << "(#{issue.status.name}) " if journal.new_value_for('status_id')
                  s << issue.subject
                  @issue = issue
                  @users = to_users + cc_users
                  @journal = journal
                  @journal_details = journal.visible_details(@users.first)
                  @issue_url = url_for(:controller => 'issues', :action => 'show', :id => issue, :anchor => "change-#{journal.id}")
                  mail :to => to_users,
                    :cc => cc_users,
                    :subject => s
                end
                # Notifies users about an issue update
                def self.deliver_issue_edit(journal)
                  issue = journal.journalized.reload
                  to = journal.notified_users
                  cc = journal.notified_watchers - to
                  journal.each_notification(to + cc) do |users|
                    issue.each_notification(users) do |users2|
                      Mailer.issue_edit(journal, to & users2, cc & users2).deliver
                    end
                  end
                end
                def reminder(user, issues, days)
                  set_language_if_valid user.language
                  @issues = issues
                  @days = days
                  @issues_url = url_for(:controller => 'issues', :action => 'index',
                                              :set_filter => 1, :assigned_to_id => user.id,
                                              :sort => 'due_date:asc')
                  mail :to => user,
                    :subject => l(:mail_subject_reminder, :count => issues.size, :days => days)
                end
                # Builds a Mail::Message object used to email users belonging to the added document's project.
                #
                # Example:
                #   document_added(document) => Mail::Message object
                #   Mailer.document_added(document).deliver => sends an email to the document's project recipients
                def document_added(document)
                  redmine_headers 'Project' => document.project.identifier
                  @author = User.current
                  @document = document
                  @document_url = url_for(:controller => 'documents', :action => 'show', :id => document)
                  mail :to => document.notified_users,
                    :subject => "[#{document.project.name}] #{l(:label_document_new)}: #{document.title}"
                end
                # Builds a Mail::Message object used to email recipients of a project when an attachements are added.
                #
                # Example:
                #   attachments_added(attachments) => Mail::Message object
                #   Mailer.attachments_added(attachments).deliver => sends an email to the project's recipients
                def attachments_added(attachments)
                  container = attachments.first.container
                  added_to = ''
                  added_to_url = ''
                  @author = attachments.first.author
                  case container.class.name
                  when 'Project'
                    added_to_url = url_for(:controller => 'files', :action => 'index', :project_id => container)
                    added_to = "#{l(:label_project)}: #{container}"
                    recipients = container.project.notified_users.select {|user| user.allowed_to?(:view_files, container.project)}
                  when 'Version'
                    added_to_url = url_for(:controller => 'files', :action => 'index', :project_id => container.project)
                    added_to = "#{l(:label_version)}: #{container.name}"
                    recipients = container.project.notified_users.select {|user| user.allowed_to?(:view_files, container.project)}
                  when 'Document'
                    added_to_url = url_for(:controller => 'documents', :action => 'show', :id => container.id)
                    added_to = "#{l(:label_document)}: #{container.title}"
                    recipients = container.notified_users
                  end
                  redmine_headers 'Project' => container.project.identifier
                  @attachments = attachments
                  @added_to = added_to
                  @added_to_url = added_to_url
                  mail :to => recipients,
                    :subject => "[#{container.project.name}] #{l(:label_attachment_new)}"
                end
                # Builds a Mail::Message object used to email recipients of a news' project when a news item is added.
                #
                # Example:
                #   news_added(news) => Mail::Message object
                #   Mailer.news_added(news).deliver => sends an email to the news' project recipients
                def news_added(news)
                  redmine_headers 'Project' => news.project.identifier
                  @author = news.author
                  message_id news
                  references news
                  @news = news
                  @news_url = url_for(:controller => 'news', :action => 'show', :id => news)
                  mail :to => news.notified_users,
                    :cc => news.notified_watchers_for_added_news,
                    :subject => "[#{news.project.name}] #{l(:label_news)}: #{news.title}"
                end
                # Builds a Mail::Message object used to email recipients of a news' project when a news comment is added.
                #
                # Example:
                #   news_comment_added(comment) => Mail::Message object
                #   Mailer.news_comment_added(comment) => sends an email to the news' project recipients
                def news_comment_added(comment)
                  news = comment.commented
                  redmine_headers 'Project' => news.project.identifier
                  @author = comment.author
                  message_id comment
                  references news
                  @news = news
                  @comment = comment
                  @news_url = url_for(:controller => 'news', :action => 'show', :id => news)
                  mail :to => news.notified_users,
                   :cc => news.notified_watchers,
                   :subject => "Re: [#{news.project.name}] #{l(:label_news)}: #{news.title}"
                end
                # Builds a Mail::Message object used to email the recipients of the specified message that was posted.
                #
                # Example:
                #   message_posted(message) => Mail::Message object
                #   Mailer.message_posted(message).deliver => sends an email to the recipients
                def message_posted(message)
                  redmine_headers 'Project' => message.project.identifier,
                                  'Topic-Id' => (message.parent_id || message.id)
                  @author = message.author
                  message_id message
                  references message.root
                  recipients = message.notified_users
                  cc = ((message.root.notified_watchers + message.board.notified_watchers).uniq - recipients)
                  @message = message
                  @message_url = url_for(message.event_url)
                  mail :to => recipients,
                    :cc => cc,
                    :subject => "[#{message.board.project.name} - #{message.board.name} - msg#{message.root.id}] #{message.subject}"
                end
                # Builds a Mail::Message object used to email the recipients of a project of the specified wiki content was added.
                #
                # Example:
                #   wiki_content_added(wiki_content) => Mail::Message object
                #   Mailer.wiki_content_added(wiki_content).deliver => sends an email to the project's recipients
                def wiki_content_added(wiki_content)
                  redmine_headers 'Project' => wiki_content.project.identifier,
                                  'Wiki-Page-Id' => wiki_content.page.id
                  @author = wiki_content.author
                  message_id wiki_content
                  recipients = wiki_content.notified_users
                  cc = wiki_content.page.wiki.notified_watchers - recipients
                  @wiki_content = wiki_content
                  @wiki_content_url = url_for(:controller => 'wiki', :action => 'show',
                                                    :project_id => wiki_content.project,
                                                    :id => wiki_content.page.title)
                  mail :to => recipients,
                    :cc => cc,
                    :subject => "[#{wiki_content.project.name}] #{l(:mail_subject_wiki_content_added, :id => wiki_content.page.pretty_title)}"
                end
                # Builds a Mail::Message object used to email the recipients of a project of the specified wiki content was updated.
                #
                # Example:
                #   wiki_content_updated(wiki_content) => Mail::Message object
                #   Mailer.wiki_content_updated(wiki_content).deliver => sends an email to the project's recipients
                def wiki_content_updated(wiki_content)
                  redmine_headers 'Project' => wiki_content.project.identifier,
                                  'Wiki-Page-Id' => wiki_content.page.id
                  @author = wiki_content.author
                  message_id wiki_content
                  recipients = wiki_content.notified_users
                  cc = wiki_content.page.wiki.notified_watchers + wiki_content.page.notified_watchers - recipients
                  @wiki_content = wiki_content
                  @wiki_content_url = url_for(:controller => 'wiki', :action => 'show',
                                                    :project_id => wiki_content.project,
                                                    :id => wiki_content.page.title)
                  @wiki_diff_url = url_for(:controller => 'wiki', :action => 'diff',
                                                 :project_id => wiki_content.project, :id => wiki_content.page.title,
                                                 :version => wiki_content.version)
                  mail :to => recipients,
                    :cc => cc,
                    :subject => "[#{wiki_content.project.name}] #{l(:mail_subject_wiki_content_updated, :id => wiki_content.page.pretty_title)}"
                end
                # Builds a Mail::Message object used to email the specified user their account information.
                #
                # Example:
                #   account_information(user, password) => Mail::Message object
                #   Mailer.account_information(user, password).deliver => sends account information to the user
                def account_information(user, password)
                  set_language_if_valid user.language
                  @user = user
                  @password = password
                  @login_url = url_for(:controller => 'account', :action => 'login')
                  mail :to => user.mail,
                    :subject => l(:mail_subject_register, Setting.app_title)
                end
                # Builds a Mail::Message object used to email all active administrators of an account activation request.
                #
                # Example:
                #   account_activation_request(user) => Mail::Message object
                #   Mailer.account_activation_request(user).deliver => sends an email to all active administrators
                def account_activation_request(user)
                  # Send the email to all active administrators
                  recipients = User.active.where(:admin => true)
                  @user = user
                  @url = url_for(:controller => 'users', :action => 'index',
                                       :status => User::STATUS_REGISTERED,
                                       :sort_key => 'created_on', :sort_order => 'desc')
                  mail :to => recipients,
                    :subject => l(:mail_subject_account_activation_request, Setting.app_title)
                end
                # Builds a Mail::Message object used to email the specified user that their account was activated by an administrator.
                #
                # Example:
                #   account_activated(user) => Mail::Message object
                #   Mailer.account_activated(user).deliver => sends an email to the registered user
                def account_activated(user)
                  set_language_if_valid user.language
                  @user = user
                  @login_url = url_for(:controller => 'account', :action => 'login')
                  mail :to => user.mail,
                    :subject => l(:mail_subject_register, Setting.app_title)
                end
                def lost_password(token, recipient=nil)
                  set_language_if_valid(token.user.language)
                  recipient ||= token.user.mail
                  @token = token
                  @url = url_for(:controller => 'account', :action => 'lost_password', :token => token.value)
                  mail :to => recipient,
                    :subject => l(:mail_subject_lost_password, Setting.app_title)
                end
                def register(token)
                  set_language_if_valid(token.user.language)
                  @token = token
                  @url = url_for(:controller => 'account', :action => 'activate', :token => token.value)
                  mail :to => token.user.mail,
                    :subject => l(:mail_subject_register, Setting.app_title)
                end
                def test_email(user)
                  set_language_if_valid(user.language)
                  @url = url_for(:controller => 'welcome')
                  mail :to => user.mail,
                    :subject => 'Redmine test'
                end
                # Sends reminders to issue assignees
                # Available options:
                # * :days     => how many days in the future to remind about (defaults to 7)
                # * :tracker  => id of tracker for filtering issues (defaults to all trackers)
                # * :project  => id or identifier of project to process (defaults to all projects)
                # * :users    => array of user/group ids who should be reminded
                # * :version  => name of target version for filtering issues (defaults to none)
                def self.reminders(options={})
                  days = options[:days] || 7
                  project = options[:project] ? Project.find(options[:project]) : nil
                  tracker = options[:tracker] ? Tracker.find(options[:tracker]) : nil
                  target_version_id = options[:version] ? Version.named(options[:version]).pluck(:id) : nil
                  if options[:version] && target_version_id.blank?
                    raise ActiveRecord::RecordNotFound.new("Couldn't find Version with named #{options[:version]}")
                  end
                  user_ids = options[:users]
                  scope = Issue.open.where("#{Issue.table_name}.assigned_to_id IS NOT NULL" +
                    " AND #{Project.table_name}.status = #{Project::STATUS_ACTIVE}" +
                    " AND #{Issue.table_name}.due_date <= ?", days.day.from_now.to_date
                  )
                  scope = scope.where(:assigned_to_id => user_ids) if user_ids.present?
                  scope = scope.where(:project_id => project.id) if project
                  scope = scope.where(:fixed_version_id => target_version_id) if target_version_id.present?
                  scope = scope.where(:tracker_id => tracker.id) if tracker
                  issues_by_assignee = scope.includes(:status, :assigned_to, :project, :tracker).
                                            group_by(&:assigned_to)
                  issues_by_assignee.keys.each do |assignee|
                    if assignee.is_a?(Group)
                      assignee.users.each do |user|
                        issues_by_assignee[user] ||= []
                        issues_by_assignee[user] += issues_by_assignee[assignee]
                      end
                    end
                  end
                  issues_by_assignee.each do |assignee, issues|
                    reminder(assignee, issues, days).deliver if assignee.is_a?(User) && assignee.active?
                  end
                end
                # Activates/desactivates email deliveries during +block+
                def self.with_deliveries(enabled = true, &block)
                  was_enabled = ActionMailer::Base.perform_deliveries
                  ActionMailer::Base.perform_deliveries = !!enabled
                  yield
                ensure
                  ActionMailer::Base.perform_deliveries = was_enabled
                end
                # Sends emails synchronously in the given block
                def self.with_synched_deliveries(&block)
                  saved_method = ActionMailer::Base.delivery_method
                  if m = saved_method.to_s.match(%r{^async_(.+)$})
                    synched_method = m[1]
                    ActionMailer::Base.delivery_method = synched_method.to_sym
                    ActionMailer::Base.send "#{synched_method}_settings=", ActionMailer::Base.send("async_#{synched_method}_settings")
                  end
                  yield
                ensure
                  ActionMailer::Base.delivery_method = saved_method
                end
                def mail(headers={}, &block)
                  headers.reverse_merge! 'X-Mailer' => 'Redmine',
                          'X-Redmine-Host' => Setting.host_name,
                          'X-Redmine-Site' => Setting.app_title,
-                         'X-Auto-Response-Suppress' => 'OOF',
+                         'X-Auto-Response-Suppress' => 'All',
                          'Auto-Submitted' => 'auto-generated',
                          'From' => Setting.mail_from,
                          'List-Id' => "<#{Setting.mail_from.to_s.gsub('@', '.')}>"
                  # Replaces users with their email addresses
                  [:to, :cc, :bcc].each do |key|
                    if headers[key].present?
                      headers[key] = self.class.email_addresses(headers[key])
                    end
                  end
                  # Removes the author from the recipients and cc
                  # if the author does not want to receive notifications
                  # about what the author do
                  if @author && @author.logged? && @author.pref.no_self_notified
                    addresses = @author.mails
                    headers[:to] -= addresses if headers[:to].is_a?(Array)
                    headers[:cc] -= addresses if headers[:cc].is_a?(Array)
                  end
                  if @author && @author.logged?
                    redmine_headers 'Sender' => @author.login
                  end
                  # Blind carbon copy recipients
                  if Setting.bcc_recipients?
                    headers[:bcc] = [headers[:to], headers[:cc]].flatten.uniq.reject(&:blank?)
                    headers[:to] = nil
                    headers[:cc] = nil
                  end
                  if @message_id_object
                    headers[:message_id] = "<#{self.class.message_id_for(@message_id_object)}>"
                  end
                  if @references_objects
                    headers[:references] = @references_objects.collect {|o| "<#{self.class.references_for(o)}>"}.join(' ')
                  end
                  m = if block_given?
                    super headers, &block
                  else
                    super headers do |format|
                      format.text
                      format.html unless Setting.plain_text_mail?
                    end
                  end
                  set_language_if_valid @initial_language
                  m
                end
                def initialize(*args)
                  @initial_language = current_language
                  set_language_if_valid Setting.default_language
                  super
                end
                def self.deliver_mail(mail)
                  return false if mail.to.blank? && mail.cc.blank? && mail.bcc.blank?
                  begin
                    # Log errors when raise_delivery_errors is set to false, Rails does not
                    mail.raise_delivery_errors = true
                    super
                  rescue Exception => e
                    if ActionMailer::Base.raise_delivery_errors
                      raise e
                    else
                      Rails.logger.error "Email delivery error: #{e.message}"
                    end
                  end
                end
                def self.method_missing(method, *args, &block)
                  if m = method.to_s.match(%r{^deliver_(.+)$})
                    ActiveSupport::Deprecation.warn "Mailer.deliver_#{m[1]}(*args) is deprecated. Use Mailer.#{m[1]}(*args).deliver instead."
                    send(m[1], *args).deliver
                  else
                    super
                  end
                end
                # Returns an array of email addresses to notify by
                # replacing users in arg with their notified email addresses
                #
                # Example:
                #   Mailer.email_addresses(users)
                #   => ["foo@example.net", "bar@example.net"]
                def self.email_addresses(arg)
                  arr = Array.wrap(arg)
                  mails = arr.reject {|a| a.is_a? Principal}
                  users = arr - mails
                  if users.any?
                    mails += EmailAddress.
                      where(:user_id => users.map(&:id)).
                      where("is_default = ? OR notify = ?", true, true).
                      pluck(:address)
                  end
                  mails
                end
                private
                # Appends a Redmine header field (name is prepended with 'X-Redmine-')
                def redmine_headers(h)
                  h.each { |k,v| headers["X-Redmine-#{k}"] = v.to_s }
                end
                def self.token_for(object, rand=true)
                  timestamp = object.send(object.respond_to?(:created_on) ? :created_on : :updated_on)
                  hash = [
                    "redmine",
                    "#{object.class.name.demodulize.underscore}-#{object.id}",
                    timestamp.strftime("%Y%m%d%H%M%S")
                  ]
                  if rand
                    hash << Redmine::Utils.random_hex(8)
                  end
                  host = Setting.mail_from.to_s.strip.gsub(%r{^.*@|>}, '')
                  host = "#{::Socket.gethostname}.redmine" if host.empty?
                  "#{hash.join('.')}@#{host}"
                end
                # Returns a Message-Id for the given object
                def self.message_id_for(object)
                  token_for(object, true)
                end
                # Returns a uniq token for a given object referenced by all notifications
                # related to this object
                def self.references_for(object)
                  token_for(object, false)
                end
                def message_id(object)
                  @message_id_object = object
                end
                def references(object)
                  @references_objects ||= []
                  @references_objects << object
                end
                def mylogger
                  Rails.logger
                end
              end

test/unit/mail_handler_test.rb 0 -1

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2015  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,
                         :issues, :issue_statuses,
                         :workflows, :trackers, :projects_trackers,
                         :versions, :enumerations, :issue_categories,
                         :custom_fields, :custom_fields_trackers, :custom_fields_projects,
                         :boards, :messages
                FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures/mail_handler'
                def setup
                  ActionMailer::Base.deliveries.clear
                  Setting.notified_events = Redmine::Notifiable.all.collect(&:name)
                end
                def teardown
                  Setting.clear_cache
                end
                def test_add_issue
                  ActionMailer::Base.deliveries.clear
                  lft1 = new_issue_lft
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal issue.project.trackers.first, issue.tracker
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal IssueStatus.find_by_name('Resolved'), issue.status
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal Version.find_by_name('Alpha'), issue.fixed_version
                  assert_equal 2.5, issue.estimated_hours
                  assert_equal 30, issue.done_ratio
                  assert_equal [issue.id, lft1, lft1 + 1], [issue.root_id, issue.lft, issue.rgt]
                  # keywords should be removed from the email body
                  assert !issue.description.match(/^Project:/i)
                  assert !issue.description.match(/^Status:/i)
                  assert !issue.description.match(/^Start Date:/i)
                  # Email notification should be sent
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert mail.subject.include?("##{issue.id}")
                  assert mail.subject.include?('New ticket on a given project')
                end
                def test_add_issue_with_default_tracker
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email(
                            'ticket_on_given_project.eml',
                            :issue => {:tracker => 'Support request'}
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Support request', issue.tracker.name
                end
                def test_add_issue_with_status
                  # This email contains: 'Project: onlinestore' and 'Status: Resolved'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                end
                def test_add_issue_with_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_group_assignment
                  with_settings :issue_group_assignment => '1' do
                    issue = submit_email('ticket_on_given_project.eml') do |email|
                      email.gsub!('Assigned to: John Smith', 'Assigned to: B Team')
                    end
                    assert issue.is_a?(Issue)
                    assert !issue.new_record?
                    issue.reload
                    assert_equal Group.find(11), issue.assigned_to
                  end
                end
                def test_add_issue_with_partial_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :issue => {:priority => 'High'},
                            :allow_override => ['tracker']
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_nil issue.category
                  assert_equal 'High', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_spaces_between_attribute_and_separator
                  issue = submit_email(
                            'ticket_with_spaces_between_attribute_and_separator.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_attachment_to_specific_project
                  issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Ticket created by email with attachment', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'This is  a new ticket with attachments', issue.description
                  # Attachment properties
                  assert_equal 1, issue.attachments.size
                  assert_equal 'Paella.jpg', issue.attachments.first.filename
                  assert_equal 'image/jpeg', issue.attachments.first.content_type
                  assert_equal 10790, issue.attachments.first.filesize
                end
                def test_add_issue_with_custom_fields
                  issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket with custom field values', issue.subject
                  assert_equal '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'}) do |email|
                    email << "Affected version: 1.0\n"
                  end
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal '2', issue.custom_field_value(field)
                end
                def test_add_issue_should_match_assignee_on_display_name
                  user = User.generate!(:firstname => 'Foo Bar', :lastname => 'Foo Baz')
                  User.add_to_project(user, Project.find(2))
                  issue = submit_email('ticket_on_given_project.eml') do |email|
                    email.sub!(/^Assigned to.*$/, 'Assigned to: Foo Bar Foo baz')
                  end
                  assert issue.is_a?(Issue)
                  assert_equal user, issue.assigned_to
                end
                def test_add_issue_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_with_cc
                  issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
                  assert_equal 1, issue.watcher_user_ids.size
                end
                def test_add_issue_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
                  lft1 = new_issue_lft
                  assert_no_difference 'User.count' do
                    assert_difference 'Issue.count' do
                      issue = submit_email(
                                'ticket_by_unknown_user.eml',
                                :issue => {:project => 'onlinestore'},
                                :no_permission_check => '1',
                                :unknown_user => 'accept'
                              )
                      assert issue.is_a?(Issue)
                      assert issue.author.anonymous?
                      assert !issue.project.is_public?
                      assert_equal [issue.id, lft1, lft1 + 1], [issue.root_id, issue.lft, issue.rgt]
                    end
                  end
                end
                def test_add_issue_by_created_user
                  Setting.default_language = 'en'
                  assert_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_unknown_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'create'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.active?
                    assert_equal 'john.doe@somenet.foo', issue.author.mail
                    assert_equal 'John', issue.author.firstname
                    assert_equal 'Doe', issue.author.lastname
                    # account information
                    email = ActionMailer::Base.deliveries.first
                    assert_not_nil email
                    assert email.subject.include?('account activation')
                    login = mail_body(email).match(/\* Login: (.*)$/)[1].strip
                    password = mail_body(email).match(/\* Password: (.*)$/)[1].strip
                    assert_equal issue.author, User.try_to_login(login, password)
                  end
                end
                def test_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_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
                  [
-                   "X-Auto-Response-Suppress: OOF",
                    "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']
                  ActionMailer::Base.deliveries.clear
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal 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
                  # This email contains: 'Status: Resolved'
                  journal = submit_email('ticket_reply_with_status.eml')
                  assert journal.is_a?(Journal)
                  issue = Issue.find(journal.issue.id)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value
                  # keywords should be removed from the email body
                  assert !journal.notes.match(/^Status:/i)
                  assert !journal.notes.match(/^Start Date:/i)
                end
                def test_update_issue_with_attachment
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      assert_difference 'Attachment.count' do
                        assert_no_difference 'Issue.count' do
                          journal = submit_email('ticket_with_attachment.eml') do |raw|
                            raw.gsub! /^Subject: .*$/, 'Subject: Re: [Cookbook - Feature #2] (New) Add ingredients categories'
                          end
                        end
                      end
                    end
                  end
                  journal = Journal.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
                  ActionMailer::Base.deliveries.clear
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue_should_not_set_defaults
                  journal = submit_email(
                              'ticket_reply.eml',
                              :issue => {:tracker => 'Support request', :priority => 'High'}
                            )
                  assert journal.is_a?(Journal)
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal 'Normal', journal.issue.priority.name
                end
                def test_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_strip_tags_of_html_only_emails
                  issue = submit_email('ticket_html_only.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'HTML email', issue.subject
                  assert_equal 'This is a html-only email.', issue.description
                end
                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

test/unit/mailer_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2015  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 MailerTest < ActiveSupport::TestCase
                include Redmine::I18n
                include Rails::Dom::Testing::Assertions
                fixtures :projects, :enabled_modules, :issues, :users, :email_addresses, :members,
                         :member_roles, :roles, :documents, :attachments, :news,
                         :tokens, :journals, :journal_details, :changesets,
                         :trackers, :projects_trackers,
                         :issue_statuses, :enumerations, :messages, :boards, :repositories,
                         :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                         :versions,
                         :comments
                def setup
                  ActionMailer::Base.deliveries.clear
                  Setting.host_name = 'mydomain.foo'
                  Setting.protocol = 'http'
                  Setting.plain_text_mail = '0'
                  Setting.default_language = 'en'
                  User.current = nil
                end
                def test_generated_links_in_emails
                  Setting.host_name = 'mydomain.foo'
                  Setting.protocol = 'https'
                  journal = Journal.find(3)
                  assert Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'https://mydomain.foo/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'https://mydomain.foo/issues/1',
                                  "Cannot print recipes (New)",
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'https://mydomain.foo/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 & #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href^=?][title=?]',
                                  # should be https://mydomain.foo/journals/diff/3?detail_id=4
                                  # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                  # attribute value
                                  'https://mydomain.foo/journals/diff/3',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'https://mydomain.foo/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                end
                def test_generated_links_with_prefix
                  relative_url_root = Redmine::Utils.relative_url_root
                  Setting.host_name = 'mydomain.foo/rdm'
                  Setting.protocol = 'http'
                  journal = Journal.find(3)
                  assert Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/issues/1',
                                  "Cannot print recipes (New)",
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 & #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href^=?][title=?]',
                                  # should be http://mydomain.foo/rdm/journals/diff/3?detail_id=4
                                  # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                  # attribute value
                                  'http://mydomain.foo/rdm/journals/diff/3',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                end
                def test_generated_links_with_port_and_prefix
                  with_settings :host_name => '10.0.0.1:81/redmine', :protocol => 'http' do
                    Mailer.test_email(User.find(1)).deliver
                    mail = last_email
                    assert_not_nil mail
                    assert_include 'http://10.0.0.1:81/redmine', mail_body(mail)
                  end
                end
                def test_generated_links_with_port
                  with_settings :host_name => '10.0.0.1:81', :protocol => 'http' do
                    Mailer.test_email(User.find(1)).deliver
                    mail = last_email
                    assert_not_nil mail
                    assert_include 'http://10.0.0.1:81', mail_body(mail)
                  end
                end
                def test_issue_edit_should_generate_url_with_hostname_for_relations
                  journal = Journal.new(:journalized => Issue.find(1), :user => User.find(1), :created_on => Time.now)
                  journal.details << JournalDetail.new(:property => 'relation', :prop_key => 'label_relates_to', :value => 2)
                  Mailer.deliver_issue_edit(journal)
                  assert_not_nil last_email
                  assert_select_email do
                    assert_select 'a[href=?]', 'http://mydomain.foo/issues/2', :text => 'Feature request #2'
                  end
                end
                def test_generated_links_with_prefix_and_no_relative_url_root
                  relative_url_root = Redmine::Utils.relative_url_root
                  Setting.host_name = 'mydomain.foo/rdm'
                  Setting.protocol = 'http'
                  Redmine::Utils.relative_url_root = nil
                  journal = Journal.find(3)
                  assert Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_not_nil mail
                  assert_select_email do
                    # link to the main ticket
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/issues/2#change-3',
                                  :text => 'Feature request #2: Add ingredients categories'
                    # link to a referenced ticket
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/issues/1',
                                  "Cannot print recipes (New)",
                                  :text => '#1'
                    # link to a changeset
                    assert_select 'a[href=?][title=?]',
                                  'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                  'This commit fixes #1, #2 and references #1 & #3',
                                  :text => 'r2'
                    # link to a description diff
                    assert_select 'a[href^=?][title=?]',
                                  # should be http://mydomain.foo/rdm/journals/diff/3?detail_id=4
                                  # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                  # attribute value
                                  'http://mydomain.foo/rdm/journals/diff/3',
                                  'View differences',
                                  :text => 'diff'
                    # link to an attachment
                    assert_select 'a[href=?]',
                                  'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                  :text => 'source.rb'
                  end
                ensure
                  # restore it
                  Redmine::Utils.relative_url_root = relative_url_root
                end
                def test_email_headers
                  issue = Issue.find(1)
                  Mailer.deliver_issue_add(issue)
                  mail = last_email
                  assert_not_nil mail
-                 assert_equal 'OOF', mail.header['X-Auto-Response-Suppress'].to_s
+                 assert_equal 'All', mail.header['X-Auto-Response-Suppress'].to_s
                  assert_equal 'auto-generated', mail.header['Auto-Submitted'].to_s
                  assert_equal '<redmine.example.net>', mail.header['List-Id'].to_s
                end
                def test_email_headers_should_include_sender
                  issue = Issue.find(1)
                  Mailer.deliver_issue_add(issue)
                  mail = last_email
                  assert_equal issue.author.login, mail.header['X-Redmine-Sender'].to_s
                end
                def test_plain_text_mail
                  Setting.plain_text_mail = 1
                  journal = Journal.find(2)
                  Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_equal "text/plain; charset=UTF-8", mail.content_type
                  assert_equal 0, mail.parts.size
                  assert !mail.encoded.include?('href')
                end
                def test_html_mail
                  Setting.plain_text_mail = 0
                  journal = Journal.find(2)
                  Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_equal 2, mail.parts.size
                  assert mail.encoded.include?('href')
                end
                def test_from_header
                  with_settings :mail_from => 'redmine@example.net' do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  mail = last_email
                  assert_equal 'redmine@example.net', mail.from_addrs.first
                end
                def test_from_header_with_phrase
                  with_settings :mail_from => 'Redmine app <redmine@example.net>' do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  mail = last_email
                  assert_equal 'redmine@example.net', mail.from_addrs.first
                  assert_equal 'Redmine app <redmine@example.net>', mail.header['From'].to_s
                end
                def test_should_not_send_email_without_recipient
                  news = News.first
                  user = news.author
                  # Remove members except news author
                  news.project.memberships.each {|m| m.destroy unless m.user == user}
                  user.pref.no_self_notified = false
                  user.pref.save
                  User.current = user
                  Mailer.news_added(news.reload).deliver
                  assert_equal 1, last_email.bcc.size
                  # nobody to notify
                  user.pref.no_self_notified = true
                  user.pref.save
                  User.current = user
                  ActionMailer::Base.deliveries.clear
                  Mailer.news_added(news.reload).deliver
                  assert ActionMailer::Base.deliveries.empty?
                end
                def test_issue_add_message_id
                  issue = Issue.find(2)
                  Mailer.deliver_issue_add(issue)
                  mail = last_email
                  assert_match /^redmine\.issue-2\.20060719190421\.[a-f0-9]+@example\.net/, mail.message_id
                  assert_include "redmine.issue-2.20060719190421@example.net", mail.references
                end
                def test_issue_edit_message_id
                  journal = Journal.find(3)
                  journal.issue = Issue.find(2)
                  Mailer.deliver_issue_edit(journal)
                  mail = last_email
                  assert_match /^redmine\.journal-3\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                  assert_include "redmine.issue-2.20060719190421@example.net", mail.references
                  assert_select_email do
                    # link to the update
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/issues/#{journal.journalized_id}#change-#{journal.id}"
                  end
                end
                def test_message_posted_message_id
                  message = Message.find(1)
                  Mailer.message_posted(message).deliver
                  mail = last_email
                  assert_match /^redmine\.message-1\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                  assert_include "redmine.message-1.20070512151532@example.net", mail.references
                  assert_select_email do
                    # link to the message
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.id}",
                                  :text => message.subject
                  end
                end
                def test_reply_posted_message_id
                  message = Message.find(3)
                  Mailer.message_posted(message).deliver
                  mail = last_email
                  assert_match /^redmine\.message-3\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                  assert_include "redmine.message-1.20070512151532@example.net", mail.references
                  assert_select_email do
                    # link to the reply
                    assert_select "a[href=?]",
                                  "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.root.id}?r=#{message.id}#message-#{message.id}",
                                  :text => message.subject
                  end
                end
                test "#issue_add should notify project members" do
                  issue = Issue.find(1)
                  assert Mailer.deliver_issue_add(issue)
                  assert last_email.bcc.include?('dlopper@somenet.foo')
                end
                def test_issue_add_should_send_mail_to_all_user_email_address
                  EmailAddress.create!(:user_id => 3, :address => 'otheremail@somenet.foo')
                  issue = Issue.find(1)
                  assert Mailer.deliver_issue_add(issue)
                  assert last_email.bcc.include?('dlopper@somenet.foo')
                  assert last_email.bcc.include?('otheremail@somenet.foo')
                end
                test "#issue_add should not notify project members that are not allow to view the issue" do
                  issue = Issue.find(1)
                  Role.find(2).remove_permission!(:view_issues)
                  assert Mailer.deliver_issue_add(issue)
                  assert !last_email.bcc.include?('dlopper@somenet.foo')
                end
                test "#issue_add should notify issue watchers" do
                  issue = Issue.find(1)
                  user = User.find(9)
                  # minimal email notification options
                  user.pref.no_self_notified = '1'
                  user.pref.save
                  user.mail_notification = false
                  user.save
                  Watcher.create!(:watchable => issue, :user => user)
                  assert Mailer.deliver_issue_add(issue)
                  assert last_email.bcc.include?(user.mail)
                end
                test "#issue_add should not notify watchers not allowed to view the issue" do
                  issue = Issue.find(1)
                  user = User.find(9)
                  Watcher.create!(:watchable => issue, :user => user)
                  Role.non_member.remove_permission!(:view_issues)
                  assert Mailer.deliver_issue_add(issue)
                  assert !last_email.bcc.include?(user.mail)
                end
                def test_issue_add_should_include_enabled_fields
                  issue = Issue.find(2)
                  assert Mailer.deliver_issue_add(issue)
                  assert_mail_body_match '* Target version: 1.0', last_email
                  assert_select_email do
                    assert_select 'li', :text => 'Target version: 1.0'
                  end
                end
                def test_issue_add_should_not_include_disabled_fields
                  issue = Issue.find(2)
                  tracker = issue.tracker
                  tracker.core_fields -= ['fixed_version_id']
                  tracker.save!
                  assert Mailer.deliver_issue_add(issue)
                  assert_mail_body_no_match 'Target version', last_email
                  assert_select_email do
                    assert_select 'li', :text => /Target version/, :count => 0
                  end
                end
                # test mailer methods for each language
                def test_issue_add
                  issue = Issue.find(1)
                  with_each_language_as_default do
                    assert Mailer.deliver_issue_add(issue)
                  end
                end
                def test_issue_edit
                  journal = Journal.find(1)
                  with_each_language_as_default do
                    assert Mailer.deliver_issue_edit(journal)
                  end
                end
                def test_issue_edit_should_send_private_notes_to_users_with_permission_only
                  journal = Journal.find(1)
                  journal.private_notes = true
                  journal.save!
                  Role.find(2).add_permission! :view_private_notes
                  Mailer.deliver_issue_edit(journal)
                  assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
                  Role.find(2).remove_permission! :view_private_notes
                  Mailer.deliver_issue_edit(journal)
                  assert_equal %w(jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
                end
                def test_issue_edit_should_send_private_notes_to_watchers_with_permission_only
                  Issue.find(1).set_watcher(User.find_by_login('someone'))
                  journal = Journal.find(1)
                  journal.private_notes = true
                  journal.save!
                  Role.non_member.add_permission! :view_private_notes
                  Mailer.deliver_issue_edit(journal)
                  assert_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
                  Role.non_member.remove_permission! :view_private_notes
                  Mailer.deliver_issue_edit(journal)
                  assert_not_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
                end
                def test_issue_edit_should_mark_private_notes
                  journal = Journal.find(2)
                  journal.private_notes = true
                  journal.save!
                  with_settings :default_language => 'en' do
                    Mailer.deliver_issue_edit(journal)
                  end
                  assert_mail_body_match '(Private notes)', last_email
                end
                def test_issue_edit_with_relation_should_notify_users_who_can_see_the_related_issue
                  issue = Issue.generate!
                  issue.init_journal(User.find(1))
                  private_issue = Issue.generate!(:is_private => true)
                  IssueRelation.create!(:issue_from => issue, :issue_to => private_issue, :relation_type => 'relates')
                  issue.reload
                  assert_equal 1, issue.journals.size
                  journal = issue.journals.first
                  ActionMailer::Base.deliveries.clear
                  Mailer.deliver_issue_edit(journal)
                  last_email.bcc.each do |email|
                    user = User.find_by_mail(email)
                    assert private_issue.visible?(user), "Issue was not visible to #{user}"
                  end
                end
                def test_document_added
                  document = Document.find(1)
                  with_each_language_as_default do
                    assert Mailer.document_added(document).deliver
                  end
                end
                def test_attachments_added
                  attachements = [ Attachment.find_by_container_type('Document') ]
                  with_each_language_as_default do
                    assert Mailer.attachments_added(attachements).deliver
                  end
                end
                def test_version_file_added
                  attachements = [ Attachment.find_by_container_type('Version') ]
                  assert Mailer.attachments_added(attachements).deliver
                  assert_not_nil last_email.bcc
                  assert last_email.bcc.any?
                  assert_select_email do
                    assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                  end
                end
                def test_project_file_added
                  attachements = [ Attachment.find_by_container_type('Project') ]
                  assert Mailer.attachments_added(attachements).deliver
                  assert_not_nil last_email.bcc
                  assert last_email.bcc.any?
                  assert_select_email do
                    assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                  end
                end
                def test_news_added
                  news = News.first
                  with_each_language_as_default do
                    assert Mailer.news_added(news).deliver
                  end
                end
                def test_news_added_should_notify_project_news_watchers
                  user1 = User.generate!
                  user2 = User.generate!
                  news = News.find(1)
                  news.project.enabled_module('news').add_watcher(user1)
                  Mailer.news_added(news).deliver
                  assert_include user1.mail, last_email.bcc
                  assert_not_include user2.mail, last_email.bcc
                end
                def test_news_comment_added
                  comment = Comment.find(2)
                  with_each_language_as_default do
                    assert Mailer.news_comment_added(comment).deliver
                  end
                end
                def test_message_posted
                  message = Message.first
                  recipients = ([message.root] + message.root.children).collect {|m| m.author.mail if m.author}
                  recipients = recipients.compact.uniq
                  with_each_language_as_default do
                    assert Mailer.message_posted(message).deliver
                  end
                end
                def test_wiki_content_added
                  content = WikiContent.find(1)
                  with_each_language_as_default do
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      assert Mailer.wiki_content_added(content).deliver
                      assert_select_email do
                        assert_select 'a[href=?]',
                          'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                          :text => 'CookBook documentation'
                      end
                    end
                  end
                end
                def test_wiki_content_updated
                  content = WikiContent.find(1)
                  with_each_language_as_default do
                    assert_difference 'ActionMailer::Base.deliveries.size' do
                      assert Mailer.wiki_content_updated(content).deliver
                      assert_select_email do
                        assert_select 'a[href=?]',
                          'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                          :text => 'CookBook documentation'
                      end
                    end
                  end
                end
                def test_account_information
                  user = User.find(2)
                  valid_languages.each do |lang|
                    user.update_attribute :language, lang.to_s
                    user.reload
                    assert Mailer.account_information(user, 'pAsswORd').deliver
                  end
                end
                def test_lost_password
                  token = Token.find(2)
                  valid_languages.each do |lang|
                    token.user.update_attribute :language, lang.to_s
                    token.reload
                    assert Mailer.lost_password(token).deliver
                  end
                end
                def test_register
                  token = Token.find(1)
                  Setting.host_name = 'redmine.foo'
                  Setting.protocol = 'https'
                  valid_languages.each do |lang|
                    token.user.update_attribute :language, lang.to_s
                    token.reload
                    ActionMailer::Base.deliveries.clear
                    assert Mailer.register(token).deliver
                    mail = last_email
                    assert_select_email do
                      assert_select "a[href=?]",
                                    "https://redmine.foo/account/activate?token=#{token.value}",
                                    :text => "https://redmine.foo/account/activate?token=#{token.value}"
                    end
                  end
                end
                def test_test
                  user = User.find(1)
                  valid_languages.each do |lang|
                    user.update_attribute :language, lang.to_s
                    assert Mailer.test_email(user).deliver
                  end
                end
                def test_reminders
                  Mailer.reminders(:days => 42)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                  mail = last_email
                  assert mail.bcc.include?('dlopper@somenet.foo')
                  assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
                  assert_equal '1 issue(s) due in the next 42 days', mail.subject
                end
                def test_reminders_should_not_include_closed_issues
                  with_settings :default_language => 'en' do
                    Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 5,
                                    :subject => 'Closed issue', :assigned_to_id => 3,
                                    :due_date => 5.days.from_now,
                                    :author_id => 2)
                    ActionMailer::Base.deliveries.clear
                    Mailer.reminders(:days => 42)
                    assert_equal 1, ActionMailer::Base.deliveries.size
                    mail = last_email
                    assert mail.bcc.include?('dlopper@somenet.foo')
                    assert_mail_body_no_match 'Closed issue', mail
                  end
                end
                def test_reminders_for_users
                  Mailer.reminders(:days => 42, :users => ['5'])
                  assert_equal 0, ActionMailer::Base.deliveries.size # No mail for dlopper
                  Mailer.reminders(:days => 42, :users => ['3'])
                  assert_equal 1, ActionMailer::Base.deliveries.size # No mail for dlopper
                  mail = last_email
                  assert mail.bcc.include?('dlopper@somenet.foo')
                  assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
                end
                def test_reminder_should_include_issues_assigned_to_groups
                  with_settings :default_language => 'en' do
                    group = Group.generate!
                    group.users << User.find(2)
                    group.users << User.find(3)
                    Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                    :subject => 'Assigned to group', :assigned_to => group,
                                    :due_date => 5.days.from_now,
                                    :author_id => 2)
                    ActionMailer::Base.deliveries.clear
                    Mailer.reminders(:days => 7)
                    assert_equal 2, ActionMailer::Base.deliveries.size
                    assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.map(&:bcc).flatten.sort
                    ActionMailer::Base.deliveries.each do |mail|
                      assert_mail_body_match 'Assigned to group', mail
                    end
                  end
                end
                def test_reminders_with_version_option
                  with_settings :default_language => 'en' do
                    version = Version.generate!(:name => 'Acme', :project_id => 1)
                    Issue.generate!(:assigned_to => User.find(2), :due_date => 5.days.from_now)
                    Issue.generate!(:assigned_to => User.find(3), :due_date => 5.days.from_now, :fixed_version => version)
                    ActionMailer::Base.deliveries.clear
                    Mailer.reminders(:days => 42, :version => 'acme')
                    assert_equal 1, ActionMailer::Base.deliveries.size
                    mail = last_email
                    assert mail.bcc.include?('dlopper@somenet.foo')
                  end
                end
                def test_mailer_should_not_change_locale
                  # Set current language to italian
                  set_language_if_valid 'it'
                  # Send an email to a french user
                  user = User.find(1)
                  user.language = 'fr'
                  Mailer.account_activated(user).deliver
                  mail = last_email
                  assert_mail_body_match 'Votre compte', mail
                  assert_equal :it, current_language
                end
                def test_with_deliveries_off
                  Mailer.with_deliveries false do
                    Mailer.test_email(User.find(1)).deliver
                  end
                  assert ActionMailer::Base.deliveries.empty?
                  # should restore perform_deliveries
                  assert ActionMailer::Base.perform_deliveries
                end
                def test_token_for_should_strip_trailing_gt_from_address_with_full_name
                  with_settings :mail_from => "Redmine Mailer<no-reply@redmine.org>" do
                    assert_match /\Aredmine.issue-\d+\.\d+\.[0-9a-f]+@redmine.org\z/, Mailer.token_for(Issue.generate!)
                  end
                end
                def test_layout_should_include_the_emails_header
                  with_settings :emails_header => "*Header content*" do
                    with_settings :plain_text_mail => 0 do
                      assert Mailer.test_email(User.find(1)).deliver
                      assert_select_email do
                        assert_select ".header" do
                          assert_select "strong", :text => "Header content"
                        end
                      end
                    end
                    with_settings :plain_text_mail => 1 do
                      assert Mailer.test_email(User.find(1)).deliver
                      mail = last_email
                      assert_not_nil mail
                      assert_include "*Header content*", mail.body.decoded
                    end
                  end
                end
                def test_layout_should_not_include_empty_emails_header
                  with_settings :emails_header => "", :plain_text_mail => 0 do
                    assert Mailer.test_email(User.find(1)).deliver
                    assert_select_email do
                      assert_select ".header", false
                    end
                  end
                end
                def test_layout_should_include_the_emails_footer
                  with_settings :emails_footer => "*Footer content*" do
                    with_settings :plain_text_mail => 0 do
                      assert Mailer.test_email(User.find(1)).deliver
                      assert_select_email do
                        assert_select ".footer" do
                          assert_select "strong", :text => "Footer content"
                        end
                      end
                    end
                    with_settings :plain_text_mail => 1 do
                      assert Mailer.test_email(User.find(1)).deliver
                      mail = last_email
                      assert_not_nil mail
                      assert_include "\n-- \n", mail.body.decoded
                      assert_include "*Footer content*", mail.body.decoded
                    end
                  end
                end
                def test_layout_should_not_include_empty_emails_footer
                  with_settings :emails_footer => "" do
                    with_settings :plain_text_mail => 0 do
                      assert Mailer.test_email(User.find(1)).deliver
                      assert_select_email do
                        assert_select ".footer", false
                      end
                    end
                    with_settings :plain_text_mail => 1 do
                      assert Mailer.test_email(User.find(1)).deliver
                      mail = last_email
                      assert_not_nil mail
                      assert_not_include "\n-- \n", mail.body.decoded
                    end
                  end
                end
                def test_should_escape_html_templates_only
                  Issue.generate!(:project_id => 1, :tracker_id => 1, :subject => 'Subject with a <tag>')
                  mail = last_email
                  assert_equal 2, mail.parts.size
                  assert_include '<tag>', text_part.body.encoded
                  assert_include '&lt;tag&gt;', html_part.body.encoded
                end
                def test_should_raise_delivery_errors_when_raise_delivery_errors_is_true
                  mail = Mailer.test_email(User.find(1))
                  mail.delivery_method.stubs(:deliver!).raises(Exception.new("delivery error"))
                  ActionMailer::Base.raise_delivery_errors = true
                  assert_raise Exception, "delivery error" do
                    mail.deliver
                  end
                ensure
                  ActionMailer::Base.raise_delivery_errors = false
                end
                def test_should_log_delivery_errors_when_raise_delivery_errors_is_false
                  mail = Mailer.test_email(User.find(1))
                  mail.delivery_method.stubs(:deliver!).raises(Exception.new("delivery error"))
                  Rails.logger.expects(:error).with("Email delivery error: delivery error")
                  ActionMailer::Base.raise_delivery_errors = false
                  assert_nothing_raised do
                    mail.deliver
                  end
                end
                def test_with_synched_deliveries_should_yield_with_synced_deliveries
                  ActionMailer::Base.delivery_method = :async_smtp
                  ActionMailer::Base.async_smtp_settings = {:foo => 'bar'}
                  Mailer.with_synched_deliveries do
                    assert_equal :smtp, ActionMailer::Base.delivery_method
                    assert_equal({:foo => 'bar'}, ActionMailer::Base.smtp_settings)
                  end
                  assert_equal :async_smtp, ActionMailer::Base.delivery_method
                ensure
                  ActionMailer::Base.delivery_method = :test
                end
                def test_email_addresses_should_keep_addresses
                  assert_equal ["foo@example.net"],
                    Mailer.email_addresses("foo@example.net")
                  assert_equal ["foo@example.net", "bar@example.net"],
                    Mailer.email_addresses(["foo@example.net", "bar@example.net"])
                end
                def test_email_addresses_should_replace_users_with_their_email_addresses
                  assert_equal ["admin@somenet.foo"],
                    Mailer.email_addresses(User.find(1))
                  assert_equal ["admin@somenet.foo", "jsmith@somenet.foo"],
                    Mailer.email_addresses(User.where(:id => [1,2])).sort
                end
                def test_email_addresses_should_include_notified_emails_addresses_only
                  EmailAddress.create!(:user_id => 2, :address => "another@somenet.foo", :notify => false)
                  EmailAddress.create!(:user_id => 2, :address => "another2@somenet.foo")
                  assert_equal ["another2@somenet.foo", "jsmith@somenet.foo"],
                    Mailer.email_addresses(User.find(2)).sort
                end
                private
                def last_email
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  mail
                end
                def text_part
                  last_email.parts.detect {|part| part.content_type.include?('text/plain')}
                end
                def html_part
                  last_email.parts.detect {|part| part.content_type.include?('text/html')}
                end
                def with_each_language_as_default(&block)
                  valid_languages.each do |lang|
                    with_settings :default_language => lang.to_s do
                      yield lang
                    end
                  end
                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