jro_apps/redmine Commit - r10776:0ebf95d8199f

Merged r10992 from trunk (#12400)....

Jean-Philippe Lang -

r10776:0ebf95d8199f

parent child

Context file:

r10776:0ebf95d8199f

Collapse all files

app/models/custom_field.rb +7 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class CustomField < ActiveRecord::Base
               include Redmine::SubclassFactory
               has_many :custom_values, :dependent => :delete_all
               acts_as_list :scope => 'type = \'#{self.class}\''
               serialize :possible_values
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :field_format, :in => Redmine::CustomFieldFormat.available_formats
               validate :validate_custom_field
               before_validation :set_searchable
               def set_searchable
                 # make sure these fields are not searchable
                 self.searchable = false if %w(int float date bool).include?(field_format)
                 # make sure only these fields can have multiple values
                 self.multiple = false unless %w(list user version).include?(field_format)
                 true
               end
               def validate_custom_field
                 if self.field_format == "list"
                   errors.add(:possible_values, :blank) if self.possible_values.nil? || self.possible_values.empty?
                   errors.add(:possible_values, :invalid) unless self.possible_values.is_a? Array
                 end
                 if regexp.present?
                   begin
                     Regexp.new(regexp)
                   rescue
                     errors.add(:regexp, :invalid)
                   end
                 end
                 if default_value.present? && !valid_field_value?(default_value)
                   errors.add(:default_value, :invalid)
                 end
               end
               def possible_values_options(obj=nil)
                 case field_format
                 when 'user', 'version'
                   if obj.respond_to?(:project) && obj.project
                     case field_format
                     when 'user'
                       obj.project.users.sort.collect {|u| [u.to_s, u.id.to_s]}
                     when 'version'
                       obj.project.shared_versions.sort.collect {|u| [u.to_s, u.id.to_s]}
                     end
                   elsif obj.is_a?(Array)
                     obj.collect {|o| possible_values_options(o)}.reduce(:&)
                   else
                     []
                   end
                 when 'bool'
                   [[l(:general_text_Yes), '1'], [l(:general_text_No), '0']]
                 else
                   possible_values || []
                 end
               end
               def possible_values(obj=nil)
                 case field_format
                 when 'user', 'version'
                   possible_values_options(obj).collect(&:last)
                 when 'bool'
                   ['1', '0']
                 else
                   values = super()
                   if values.is_a?(Array)
                     values.each do |value|
                       value.force_encoding('UTF-8') if value.respond_to?(:force_encoding)
                     end
                   end
                   values || []
                 end
               end
               # Makes possible_values accept a multiline string
               def possible_values=(arg)
                 if arg.is_a?(Array)
                   super(arg.compact.collect(&:strip).select {|v| !v.blank?})
                 else
                   self.possible_values = arg.to_s.split(/[\n\r]+/)
                 end
               end
               def cast_value(value)
                 casted = nil
                 unless value.blank?
                   case field_format
                   when 'string', 'text', 'list'
                     casted = value
                   when 'date'
                     casted = begin; value.to_date; rescue; nil end
                   when 'bool'
                     casted = (value == '1' ? true : false)
                   when 'int'
                     casted = value.to_i
                   when 'float'
                     casted = value.to_f
                   when 'user', 'version'
                     casted = (value.blank? ? nil : field_format.classify.constantize.find_by_id(value.to_i))
                   end
                 end
                 casted
               end
               def value_from_keyword(keyword, customized)
                 possible_values_options = possible_values_options(customized)
                 if possible_values_options.present?
                   keyword = keyword.to_s.downcase
-                  possible_values_options.detect {|text, id| text.downcase == keyword}.try(:last)
+                  if v = possible_values_options.detect {|text, id| text.downcase == keyword}
+                    if v.is_a?(Array)
+                      v.last
+                    else
+                      v
+                    end
+                  end
                 else
                   keyword
                 end
               end
               # Returns a ORDER BY clause that can used to sort customized
               # objects by their value of the custom field.
               # Returns nil if the custom field can not be used for sorting.
               def order_statement
                 return nil if multiple?
                 case field_format
                   when 'string', 'text', 'list', 'date', 'bool'
                     # COALESCE is here to make sure that blank and NULL values are sorted equally
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   when 'int', 'float'
                     # Make the database cast values into numeric
                     # Postgresql will raise an error if a value can not be casted!
                     # CustomValue validations should ensure that it doesn't occur
                     "(SELECT CAST(cv_sort.value AS decimal(60,3)) FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} AND cv_sort.value <> '' AND cv_sort.value IS NOT NULL LIMIT 1)"
                   when 'user', 'version'
                     value_class.fields_for_order_statement(value_join_alias)
                   else
                     nil
                 end
               end
               # Returns a GROUP BY clause that can used to group by custom value
               # Returns nil if the custom field can not be used for grouping.
               def group_statement
                 return nil if multiple?
                 case field_format
                   when 'list', 'date', 'bool', 'int'
                     order_statement
                   when 'user', 'version'
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.base_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   else
                     nil
                 end
               end
               def join_for_order_statement
                 case field_format
                   when 'user', 'version'
                     "LEFT OUTER JOIN #{CustomValue.table_name} #{join_alias}" +
                       " ON #{join_alias}.customized_type = '#{self.class.customized_class.base_class.name}'" +
                       " AND #{join_alias}.customized_id = #{self.class.customized_class.table_name}.id" +
                       " AND #{join_alias}.custom_field_id = #{id}" +
                       " AND #{join_alias}.value <> ''" +
                       " AND #{join_alias}.id = (SELECT max(#{join_alias}_2.id) FROM #{CustomValue.table_name} #{join_alias}_2" +
                         " WHERE #{join_alias}_2.customized_type = #{join_alias}.customized_type" +
                         " AND #{join_alias}_2.customized_id = #{join_alias}.customized_id" +
                         " AND #{join_alias}_2.custom_field_id = #{join_alias}.custom_field_id)" +
                       " LEFT OUTER JOIN #{value_class.table_name} #{value_join_alias}" +
                       " ON CAST(#{join_alias}.value as decimal(60,0)) = #{value_join_alias}.id"
                   else
                     nil
                 end
               end
               def join_alias
                 "cf_#{id}"
               end
               def value_join_alias
                 join_alias + "_" + field_format
               end
               def <=>(field)
                 position <=> field.position
               end
               # Returns the class that values represent
               def value_class
                 case field_format
                   when 'user', 'version'
                     field_format.classify.constantize
                   else
                     nil
                 end
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 begin; $1.constantize; rescue nil; end
               end
               # to move in project_custom_field
               def self.for_all
                 find(:all, :conditions => ["is_for_all=?", true], :order => 'position')
               end
               def type_name
                 nil
               end
               # Returns the error messages for the given value
               # or an empty array if value is a valid value for the custom field
               def validate_field_value(value)
                 errs = []
                 if value.is_a?(Array)
                   if !multiple?
                     errs << ::I18n.t('activerecord.errors.messages.invalid')
                   end
                   if is_required? && value.detect(&:present?).nil?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                   value.each {|v| errs += validate_field_value_format(v)}
                 else
                   if is_required? && value.blank?
                     errs << ::I18n.t('activerecord.errors.messages.blank')
                   end
                   errs += validate_field_value_format(value)
                 end
                 errs
               end
               # Returns true if value is a valid value for the custom field
               def valid_field_value?(value)
                 validate_field_value(value).empty?
               end
               def format_in?(*args)
                 args.include?(field_format)
               end
               protected
               # Returns the error message for the given value regarding its format
               def validate_field_value_format(value)
                 errs = []
                 if value.present?
                   errs << ::I18n.t('activerecord.errors.messages.invalid') unless regexp.blank? or value =~ Regexp.new(regexp)
                   errs << ::I18n.t('activerecord.errors.messages.too_short', :count => min_length) if min_length > 0 and value.length < min_length
                   errs << ::I18n.t('activerecord.errors.messages.too_long', :count => max_length) if max_length > 0 and value.length > max_length
                   # Format specific validations
                   case field_format
                   when 'int'
                     errs << ::I18n.t('activerecord.errors.messages.not_a_number') unless value =~ /^[+-]?\d+$/
                   when 'float'
                     begin; Kernel.Float(value); rescue; errs << ::I18n.t('activerecord.errors.messages.invalid') end
                   when 'date'
                     errs << ::I18n.t('activerecord.errors.messages.not_a_date') unless value =~ /^\d{4}-\d{2}-\d{2}$/ && begin; value.to_date; rescue; false end
                   when 'list'
                     errs << ::I18n.t('activerecord.errors.messages.inclusion') unless possible_values.include?(value)
                   end
                 end
                 errs
               end
             end

test/fixtures/mail_handler/ticket_with_custom_fields.eml +1 0

             Return-Path: <jsmith@somenet.foo>
             Received: from osiris ([127.0.0.1])
             	by OSIRIS
             	with hMailServer ; Sun, 22 Jun 2008 12:28:07 +0200
             Message-ID: <000501c8d452$a95cd7e0$0a00a8c0@osiris>
             From: "John Smith" <jsmith@somenet.foo>
             To: <redmine@somenet.foo>
             Subject: New ticket with custom field values
             Date: Sun, 22 Jun 2008 12:28:07 +0200
             MIME-Version: 1.0
             Content-Type: text/plain;
             	format=flowed;
             	charset="iso-8859-1";
             	reply-type=original
             Content-Transfer-Encoding: 7bit
             X-Priority: 3
             X-MSMail-Priority: Normal
             X-Mailer: Microsoft Outlook Express 6.00.2900.2869
             X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2900.2869
             Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas imperdiet
             turpis et odio. Integer eget pede vel dolor euismod varius. Phasellus
             blandit eleifend augue. Nulla facilisi. Duis id diam. Class aptent taciti
             sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. In
             in urna sed tellus aliquet lobortis. Morbi scelerisque tortor in dolor. Cras
             sagittis odio eu lacus. Aliquam sem tortor, consequat sit amet, vestibulum
             id, iaculis at, lectus. Fusce tortor libero, congue ut, euismod nec, luctus
             eget, eros. Pellentesque tortor enim, feugiat in, dignissim eget, tristique
             sed, mauris. Pellentesque habitant morbi tristique senectus et netus et
             malesuada fames ac turpis egestas. Quisque sit amet libero. In hac habitasse
             platea dictumst.
             Nulla et nunc. Duis pede. Donec et ipsum. Nam ut dui tincidunt neque
             sollicitudin iaculis. Duis vitae dolor. Vestibulum eget massa. Sed lorem.
             Nullam volutpat cursus erat. Cras felis dolor, lacinia quis, rutrum et,
             dictum et, ligula. Sed erat nibh, gravida in, accumsan non, placerat sed,
             massa. Sed sodales, ante fermentum ultricies sollicitudin, massa leo
             pulvinar dui, a gravida orci mi eget odio. Nunc a lacus.
             category: Stock management
             searchable field: Value for a custom field
+            Database:  postgresql

test/unit/custom_field_test.rb +5 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class CustomFieldTest < ActiveSupport::TestCase
               fixtures :custom_fields
               def test_create
                 field = UserCustomField.new(:name => 'Money money money', :field_format => 'float')
                 assert field.save
               end
               def test_before_validation
                 field = CustomField.new(:name => 'test_before_validation', :field_format => 'int')
                 field.searchable = true
                 assert field.save
                 assert_equal false, field.searchable
                 field.searchable = true
                 assert field.save
                 assert_equal false, field.searchable
               end
               def test_regexp_validation
                 field = IssueCustomField.new(:name => 'regexp', :field_format => 'text', :regexp => '[a-z0-9')
                 assert !field.save
                 assert_include I18n.t('activerecord.errors.messages.invalid'),
                                field.errors[:regexp]
                 field.regexp = '[a-z0-9]'
                 assert field.save
               end
               def test_default_value_should_be_validated
                 field = CustomField.new(:name => 'Test', :field_format => 'int')
                 field.default_value = 'abc'
                 assert !field.valid?
                 field.default_value = '6'
                 assert field.valid?
               end
               def test_default_value_should_not_be_validated_when_blank
                 field = CustomField.new(:name => 'Test', :field_format => 'list', :possible_values => ['a', 'b'], :is_required => true, :default_value => '')
                 assert field.valid?
               end
               def test_possible_values_should_accept_an_array
                 field = CustomField.new
                 field.possible_values = ["One value", ""]
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_string
                 field = CustomField.new
                 field.possible_values = "One value"
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_multiline_string
                 field = CustomField.new
                 field.possible_values = "One value\nAnd another one  \r\n \n"
                 assert_equal ["One value", "And another one"], field.possible_values
               end
               if "string".respond_to?(:encoding)
                 def test_possible_values_stored_as_binary_should_be_utf8_encoded
                   field = CustomField.find(11)
                   assert_kind_of Array, field.possible_values
                   assert field.possible_values.size > 0
                   field.possible_values.each do |value|
                     assert_equal "UTF-8", value.encoding.name
                   end
                 end
               end
               def test_destroy
                 field = CustomField.find(1)
                 assert field.destroy
               end
               def test_new_subclass_instance_should_return_an_instance
                 f = CustomField.new_subclass_instance('IssueCustomField')
                 assert_kind_of IssueCustomField, f
               end
               def test_new_subclass_instance_should_set_attributes
                 f = CustomField.new_subclass_instance('IssueCustomField', :name => 'Test')
                 assert_kind_of IssueCustomField, f
                 assert_equal 'Test', f.name
               end
               def test_new_subclass_instance_with_invalid_class_name_should_return_nil
                 assert_nil CustomField.new_subclass_instance('WrongClassName')
               end
               def test_new_subclass_instance_with_non_subclass_name_should_return_nil
                 assert_nil CustomField.new_subclass_instance('Project')
               end
               def test_string_field_validation_with_blank_value
                 f = CustomField.new(:field_format => 'string')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 f.is_required = true
                 assert !f.valid_field_value?(nil)
                 assert !f.valid_field_value?('')
               end
               def test_string_field_validation_with_min_and_max_lengths
                 f = CustomField.new(:field_format => 'string', :min_length => 2, :max_length => 5)
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('a' * 2)
                 assert !f.valid_field_value?('a')
                 assert !f.valid_field_value?('a' * 6)
               end
               def test_string_field_validation_with_regexp
                 f = CustomField.new(:field_format => 'string', :regexp => '^[A-Z0-9]*$')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('ABC')
                 assert !f.valid_field_value?('abc')
               end
               def test_date_field_validation
                 f = CustomField.new(:field_format => 'date')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('1975-07-14')
                 assert !f.valid_field_value?('1975-07-33')
                 assert !f.valid_field_value?('abc')
               end
               def test_list_field_validation
                 f = CustomField.new(:field_format => 'list', :possible_values => ['value1', 'value2'])
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('value2')
                 assert !f.valid_field_value?('abc')
               end
               def test_int_field_validation
                 f = CustomField.new(:field_format => 'int')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('123')
                 assert f.valid_field_value?('+123')
                 assert f.valid_field_value?('-123')
                 assert !f.valid_field_value?('6abc')
               end
               def test_float_field_validation
                 f = CustomField.new(:field_format => 'float')
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?('11.2')
                 assert f.valid_field_value?('-6.250')
                 assert f.valid_field_value?('5')
                 assert !f.valid_field_value?('6abc')
               end
               def test_multi_field_validation
                 f = CustomField.new(:field_format => 'list', :multiple => 'true', :possible_values => ['value1', 'value2'])
                 assert f.valid_field_value?(nil)
                 assert f.valid_field_value?('')
                 assert f.valid_field_value?([])
                 assert f.valid_field_value?([nil])
                 assert f.valid_field_value?([''])
                 assert f.valid_field_value?('value2')
                 assert !f.valid_field_value?('abc')
                 assert f.valid_field_value?(['value2'])
                 assert !f.valid_field_value?(['abc'])
                 assert f.valid_field_value?(['', 'value2'])
                 assert !f.valid_field_value?(['', 'abc'])
                 assert f.valid_field_value?(['value1', 'value2'])
                 assert !f.valid_field_value?(['value1', 'abc'])
               end
               def test_value_class_should_return_the_class_used_for_fields_values
                 assert_equal User, CustomField.new(:field_format => 'user').value_class
                 assert_equal Version, CustomField.new(:field_format => 'version').value_class
               end
               def test_value_class_should_return_nil_for_other_fields
                 assert_nil CustomField.new(:field_format => 'text').value_class
                 assert_nil CustomField.new.value_class
               end
+              def test_value_from_keyword_for_list_custom_field
+                field = CustomField.find(1)
+                assert_equal 'PostgreSQL', field.value_from_keyword('postgresql', Issue.find(1))
+              end
             end

test/unit/mail_handler_test.rb +2 -2

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

General Comments 0

Write
Preview

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

No TODOs yet

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

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