jro_apps/redmine Commit - r12418:17a5f26e5027

adjust tests to awesome_nested_set new node lft and rgt value behavior change...

Toshi MARUYAMA -

r12418:17a5f26e5027

parent child

Context file:

r12418:17a5f26e5027

Collapse all files

test/test_helper.rb +12 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 'shoulda'
             ENV["RAILS_ENV"] = "test"
             require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
             require 'rails/test_help'
             require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
             require File.expand_path(File.dirname(__FILE__) + '/object_helpers')
             include ObjectHelpers
+            require 'awesome_nested_set/version'
             class ActiveSupport::TestCase
               include ActionDispatch::TestProcess
               self.use_transactional_fixtures = true
               self.use_instantiated_fixtures  = false
               def log_user(login, password)
                 User.anonymous
                 get "/login"
                 assert_equal nil, session[:user_id]
                 assert_response :success
                 assert_template "account/login"
                 post "/login", :username => login, :password => password
                 assert_equal login, User.find(session[:user_id]).login
               end
               def uploaded_test_file(name, mime)
                 fixture_file_upload("files/#{name}", mime, true)
               end
               def credentials(user, password=nil)
                 {'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
               end
               # Mock out a file
               def self.mock_file
                 file = 'a_file.png'
                 file.stubs(:size).returns(32)
                 file.stubs(:original_filename).returns('a_file.png')
                 file.stubs(:content_type).returns('image/png')
                 file.stubs(:read).returns(false)
                 file
               end
               def mock_file
                 self.class.mock_file
               end
               def mock_file_with_options(options={})
                 file = ''
                 file.stubs(:size).returns(32)
                 original_filename = options[:original_filename] || nil
                 file.stubs(:original_filename).returns(original_filename)
                 content_type = options[:content_type] || nil
                 file.stubs(:content_type).returns(content_type)
                 file.stubs(:read).returns(false)
                 file
               end
               # Use a temporary directory for attachment related tests
               def set_tmp_attachments_directory
                 Dir.mkdir "#{Rails.root}/tmp/test" unless File.directory?("#{Rails.root}/tmp/test")
                 unless File.directory?("#{Rails.root}/tmp/test/attachments")
                   Dir.mkdir "#{Rails.root}/tmp/test/attachments"
                 end
                 Attachment.storage_path = "#{Rails.root}/tmp/test/attachments"
               end
               def set_fixtures_attachments_directory
                 Attachment.storage_path = "#{Rails.root}/test/fixtures/files"
               end
               def with_settings(options, &block)
                 saved_settings = options.keys.inject({}) do |h, k|
                   h[k] = case Setting[k]
                     when Symbol, false, true, nil
                       Setting[k]
                     else
                       Setting[k].dup
                     end
                   h
                 end
                 options.each {|k, v| Setting[k] = v}
                 yield
               ensure
                 saved_settings.each {|k, v| Setting[k] = v} if saved_settings
               end
               # Yields the block with user as the current user
               def with_current_user(user, &block)
                 saved_user = User.current
                 User.current = user
                 yield
               ensure
                 User.current = saved_user
               end
               def change_user_password(login, new_password)
                 user = User.where(:login => login).first
                 user.password, user.password_confirmation = new_password, new_password
                 user.save!
               end
               def self.ldap_configured?
                 @test_ldap = Net::LDAP.new(:host => '127.0.0.1', :port => 389)
                 return @test_ldap.bind
               rescue Exception => e
                 # LDAP is not listening
                 return nil
               end
               def self.convert_installed?
                 Redmine::Thumbnail.convert_available?
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
               end
               # Returns the url of the subversion test repository
               def self.subversion_repository_url
                 path = repository_path('subversion')
                 path = '/' + path unless path.starts_with?('/')
                 "file://#{path}"
               end
               # Returns true if the +vendor+ test repository is configured
               def self.repository_configured?(vendor)
                 File.directory?(repository_path(vendor))
               end
               def repository_path_hash(arr)
                 hs = {}
                 hs[:path]  = arr.join("/")
                 hs[:param] = arr.join("/")
                 hs
               end
               def assert_save(object)
                 saved = object.save
                 message = "#{object.class} could not be saved"
                 errors = object.errors.full_messages.map {|m| "- #{m}"}
                 message << ":\n#{errors.join("\n")}" if errors.any?
                 assert_equal true, saved, message
               end
               def assert_error_tag(options={})
                 assert_tag({:attributes => { :id => 'errorExplanation' }}.merge(options))
               end
               def assert_include(expected, s, message=nil)
                 assert s.include?(expected), (message || "\"#{expected}\" not found in \"#{s}\"")
               end
               def assert_not_include(expected, s, message=nil)
                 assert !s.include?(expected), (message || "\"#{expected}\" found in \"#{s}\"")
               end
               def assert_select_in(text, *args, &block)
                 d = HTML::Document.new(CGI::unescapeHTML(String.new(text))).root
                 assert_select(d, *args, &block)
               end
               def assert_mail_body_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_include expected, mail_body(mail), message
                 else
                   assert_match expected, mail_body(mail), message
                 end
               end
               def assert_mail_body_no_match(expected, mail, message=nil)
                 if expected.is_a?(String)
                   assert_not_include expected, mail_body(mail), message
                 else
                   assert_no_match expected, mail_body(mail), message
                 end
               end
               def mail_body(mail)
                 mail.parts.first.body.encoded
               end
+              # awesome_nested_set new node lft and rgt value changed this refactor revision.
+              #   https://github.com/collectiveidea/awesome_nested_set/commit/199fca9bb938e40200cd90714dc69247ef017c61
+              # The reason of behavior change is "self.class.base_class.unscoped" added this line.
+              #   https://github.com/collectiveidea/awesome_nested_set/commit/199fca9bb9#diff-f61b59a5e6319024e211b0ffdd0e4ef1R273
+              # It seems correct behavior because of this line comment.
+              #   https://github.com/collectiveidea/awesome_nested_set/blame/199fca9bb9/lib/awesome_nested_set/model.rb#L278
+              def new_issue_lft
+                ::AwesomeNestedSet::VERSION > "2.1.6" ? Issue.maximum(:rgt) + 1 : 1
+              end
             end
             module Redmine
               module ApiTest
                 # Base class for API tests
                 class Base < ActionDispatch::IntegrationTest
                   # Test that a request allows the three types of API authentication
                   #
                   # * HTTP Basic with username and password
                   # * HTTP Basic with an api key for the username
                   # * Key based with the key=X parameter
                   #
                   # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
                   # @param [String] url the request url
                   # @param [optional, Hash] parameters additional request parameters
                   # @param [optional, Hash] options additional options
                   # @option options [Symbol] :success_code Successful response code (:success)
                   # @option options [Symbol] :failure_code Failure response code (:unauthorized)
                   def self.should_allow_api_authentication(http_method, url, parameters={}, options={})
                     should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters, options)
                     should_allow_http_basic_auth_with_key(http_method, url, parameters, options)
                     should_allow_key_based_auth(http_method, url, parameters, options)
                   end
                   # Test that a request allows the username and password for HTTP BASIC
                   #
                   # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
                   # @param [String] url the request url
                   # @param [optional, Hash] parameters additional request parameters
                   # @param [optional, Hash] options additional options
                   # @option options [Symbol] :success_code Successful response code (:success)
                   # @option options [Symbol] :failure_code Failure response code (:unauthorized)
                   def self.should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters={}, options={})
                     success_code = options[:success_code] || :success
                     failure_code = options[:failure_code] || :unauthorized
                     context "should allow http basic auth using a username and password for #{http_method} #{url}" do
                       context "with a valid HTTP authentication" do
                         setup do
                           @user = User.generate! do |user|
                             user.admin = true
                             user.password = 'my_password'
                           end
                           send(http_method, url, parameters, credentials(@user.login, 'my_password'))
                         end
                         should_respond_with success_code
                         should_respond_with_content_type_based_on_url(url)
                         should "login as the user" do
                           assert_equal @user, User.current
                         end
                       end
                       context "with an invalid HTTP authentication" do
                         setup do
                           @user = User.generate!
                           send(http_method, url, parameters, credentials(@user.login, 'wrong_password'))
                         end
                         should_respond_with failure_code
                         should_respond_with_content_type_based_on_url(url)
                         should "not login as the user" do
                           assert_equal User.anonymous, User.current
                         end
                       end
                       context "without credentials" do
                         setup do
                           send(http_method, url, parameters)
                         end
                         should_respond_with failure_code
                         should_respond_with_content_type_based_on_url(url)
                         should "include_www_authenticate_header" do
                           assert @controller.response.headers.has_key?('WWW-Authenticate')
                         end
                       end
                     end
                   end
                   # Test that a request allows the API key with HTTP BASIC
                   #
                   # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
                   # @param [String] url the request url
                   # @param [optional, Hash] parameters additional request parameters
                   # @param [optional, Hash] options additional options
                   # @option options [Symbol] :success_code Successful response code (:success)
                   # @option options [Symbol] :failure_code Failure response code (:unauthorized)
                   def self.should_allow_http_basic_auth_with_key(http_method, url, parameters={}, options={})
                     success_code = options[:success_code] || :success
                     failure_code = options[:failure_code] || :unauthorized
                     context "should allow http basic auth with a key for #{http_method} #{url}" do
                       context "with a valid HTTP authentication using the API token" do
                         setup do
                           @user = User.generate! do |user|
                             user.admin = true
                           end
                           @token = Token.create!(:user => @user, :action => 'api')
                           send(http_method, url, parameters, credentials(@token.value, 'X'))
                         end
                         should_respond_with success_code
                         should_respond_with_content_type_based_on_url(url)
                         should_be_a_valid_response_string_based_on_url(url)
                         should "login as the user" do
                           assert_equal @user, User.current
                         end
                       end
                       context "with an invalid HTTP authentication" do
                         setup do
                           @user = User.generate!
                           @token = Token.create!(:user => @user, :action => 'feeds')
                           send(http_method, url, parameters, credentials(@token.value, 'X'))
                         end
                         should_respond_with failure_code
                         should_respond_with_content_type_based_on_url(url)
                         should "not login as the user" do
                           assert_equal User.anonymous, User.current
                         end
                       end
                     end
                   end
                   # Test that a request allows full key authentication
                   #
                   # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
                   # @param [String] url the request url, without the key=ZXY parameter
                   # @param [optional, Hash] parameters additional request parameters
                   # @param [optional, Hash] options additional options
                   # @option options [Symbol] :success_code Successful response code (:success)
                   # @option options [Symbol] :failure_code Failure response code (:unauthorized)
                   def self.should_allow_key_based_auth(http_method, url, parameters={}, options={})
                     success_code = options[:success_code] || :success
                     failure_code = options[:failure_code] || :unauthorized
                     context "should allow key based auth using key=X for #{http_method} #{url}" do
                       context "with a valid api token" do
                         setup do
                           @user = User.generate! do |user|
                             user.admin = true
                           end
                           @token = Token.create!(:user => @user, :action => 'api')
                           # Simple url parse to add on ?key= or &key=
                           request_url = if url.match(/\?/)
                                           url + "&key=#{@token.value}"
                                         else
                                           url + "?key=#{@token.value}"
                                         end
                           send(http_method, request_url, parameters)
                         end
                         should_respond_with success_code
                         should_respond_with_content_type_based_on_url(url)
                         should_be_a_valid_response_string_based_on_url(url)
                         should "login as the user" do
                           assert_equal @user, User.current
                         end
                       end
                       context "with an invalid api token" do
                         setup do
                           @user = User.generate! do |user|
                             user.admin = true
                           end
                           @token = Token.create!(:user => @user, :action => 'feeds')
                           # Simple url parse to add on ?key= or &key=
                           request_url = if url.match(/\?/)
                                           url + "&key=#{@token.value}"
                                         else
                                           url + "?key=#{@token.value}"
                                         end
                           send(http_method, request_url, parameters)
                         end
                         should_respond_with failure_code
                         should_respond_with_content_type_based_on_url(url)
                         should "not login as the user" do
                           assert_equal User.anonymous, User.current
                         end
                       end
                     end
                     context "should allow key based auth using X-Redmine-API-Key header for #{http_method} #{url}" do
                       setup do
                         @user = User.generate! do |user|
                           user.admin = true
                         end
                         @token = Token.create!(:user => @user, :action => 'api')
                         send(http_method, url, parameters, {'X-Redmine-API-Key' => @token.value.to_s})
                       end
                       should_respond_with success_code
                       should_respond_with_content_type_based_on_url(url)
                       should_be_a_valid_response_string_based_on_url(url)
                       should "login as the user" do
                         assert_equal @user, User.current
                       end
                     end
                   end
                   # Uses should_respond_with_content_type based on what's in the url:
                   #
                   # '/project/issues.xml' => should_respond_with_content_type :xml
                   # '/project/issues.json' => should_respond_with_content_type :json
                   #
                   # @param [String] url Request
                   def self.should_respond_with_content_type_based_on_url(url)
                     case
                     when url.match(/xml/i)
                       should "respond with XML" do
                         assert_equal 'application/xml', @response.content_type
                       end
                     when url.match(/json/i)
                       should "respond with JSON" do
                         assert_equal 'application/json', @response.content_type
                       end
                     else
                       raise "Unknown content type for should_respond_with_content_type_based_on_url: #{url}"
                     end
                   end
                   # Uses the url to assert which format the response should be in
                   #
                   # '/project/issues.xml' => should_be_a_valid_xml_string
                   # '/project/issues.json' => should_be_a_valid_json_string
                   #
                   # @param [String] url Request
                   def self.should_be_a_valid_response_string_based_on_url(url)
                     case
                     when url.match(/xml/i)
                       should_be_a_valid_xml_string
                     when url.match(/json/i)
                       should_be_a_valid_json_string
                     else
                       raise "Unknown content type for should_be_a_valid_response_based_on_url: #{url}"
                     end
                   end
                   # Checks that the response is a valid JSON string
                   def self.should_be_a_valid_json_string
                     should "be a valid JSON string (or empty)" do
                       assert(response.body.blank? || ActiveSupport::JSON.decode(response.body))
                     end
                   end
                   # Checks that the response is a valid XML string
                   def self.should_be_a_valid_xml_string
                     should "be a valid XML string" do
                       assert REXML::Document.new(response.body)
                     end
                   end
                   def self.should_respond_with(status)
                     should "respond with #{status}" do
                       assert_response status
                     end
                   end
                 end
               end
             end
             # URL helpers do not work with config.threadsafe!
             # https://github.com/rspec/rspec-rails/issues/476#issuecomment-4705454
             ActionView::TestCase::TestController.instance_eval do
               helper Rails.application.routes.url_helpers
             end
             ActionView::TestCase::TestController.class_eval do
               def _routes
                 Rails.application.routes
               end
             end

test/unit/issue_nested_set_test.rb +41 -48

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 IssueNestedSetTest < ActiveSupport::TestCase
               fixtures :projects, :users, :roles,
                        :trackers, :projects_trackers,
                        :issue_statuses, :issue_categories, :issue_relations,
                        :enumerations,
                        :issues
               def test_new_record_is_leaf
                 i = Issue.new
                 assert i.leaf?
               end
               def test_create_root_issue
+                lft1 = new_issue_lft
                 issue1 = Issue.generate!
+                lft2 = new_issue_lft
                 issue2 = Issue.generate!
                 issue1.reload
                 issue2.reload
+                assert_equal [issue1.id, nil, lft1, lft1 + 1], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]
-                assert_equal [issue1.id, nil, 1, 2], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]
+                assert_equal [issue2.id, nil, lft2, lft2 + 1], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]
-                assert_equal [issue2.id, nil, 1, 2], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]
               end
               def test_create_child_issue
+                lft = new_issue_lft
                 parent = Issue.generate!
                 child =  Issue.generate!(:parent_issue_id => parent.id)
                 parent.reload
                 child.reload
+                assert_equal [parent.id, nil,       lft,     lft + 3], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]
-                assert_equal [parent.id, nil, 1, 4], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]
+                assert_equal [parent.id, parent.id, lft + 1, lft + 2], [child.root_id, child.parent_id, child.lft, child.rgt]
-                assert_equal [parent.id, parent.id, 2, 3], [child.root_id, child.parent_id, child.lft, child.rgt]
               end
               def test_creating_a_child_in_a_subproject_should_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 3, :tracker_id => 2, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert_save child
                 assert_equal issue, child.reload.parent
               end
               def test_creating_a_child_in_an_invalid_project_should_not_validate
                 issue = Issue.generate!
                 child = Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                   :subject => 'child', :parent_issue_id => issue.id)
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_move_a_root_to_child
+                lft = new_issue_lft
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child = Issue.generate!(:parent_issue_id => parent1.id)
                 parent2.parent_issue_id = parent1.id
                 parent2.save!
                 child.reload
                 parent1.reload
                 parent2.reload
+                assert_equal [parent1.id, lft,     lft + 5], [parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [parent1.id, lft + 3, lft + 4], [parent2.root_id, parent2.lft, parent2.rgt]
-                assert_equal [parent1.id, 4, 5], [parent2.root_id, parent2.lft, parent2.rgt]
+                assert_equal [parent1.id, lft + 1, lft + 2], [child.root_id, child.lft, child.rgt]
-                assert_equal [parent1.id, 2, 3], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_root
+                lft1 = new_issue_lft
                 parent1 = Issue.generate!
+                lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 child.parent_issue_id = nil
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
+                assert_equal [parent1.id, lft1, lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [parent2.id, lft2, lft2 + 1], [parent2.root_id, parent2.lft, parent2.rgt]
-                assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
                 assert_equal [child.id, 1, 2], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_to_another_issue
+                lft1 = new_issue_lft
                 parent1 = Issue.generate!
+                lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 child.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 parent1.reload
                 parent2.reload
+                assert_equal [parent1.id, lft1,     lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [parent2.id, lft2,     lft2 + 3], [parent2.root_id, parent2.lft, parent2.rgt]
-                assert_equal [parent2.id, 1, 4], [parent2.root_id, parent2.lft, parent2.rgt]
+                assert_equal [parent2.id, lft2 + 1, lft2 + 2], [child.root_id,   child.lft,   child.rgt]
-                assert_equal [parent2.id, 2, 3], [child.root_id, child.lft, child.rgt]
               end
               def test_move_a_child_with_descendants_to_another_issue
+                lft1 = new_issue_lft
                 parent1 = Issue.generate!
+                lft2 = new_issue_lft
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 parent1.reload
                 parent2.reload
                 child.reload
                 grandchild.reload
+                assert_equal [parent1.id, lft1,     lft1 + 5], [parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [parent1.id, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [parent2.id, lft2,     lft2 + 1], [parent2.root_id, parent2.lft, parent2.rgt]
-                assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
+                assert_equal [parent1.id, lft1 + 1, lft1 + 4], [child.root_id, child.lft, child.rgt]
-                assert_equal [parent1.id, 2, 5], [child.root_id, child.lft, child.rgt]
+                assert_equal [parent1.id, lft1 + 2, lft1 + 3], [grandchild.root_id, grandchild.lft, grandchild.rgt]
-                assert_equal [parent1.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
                 child.reload.parent_issue_id = parent2.id
                 child.save!
                 child.reload
                 grandchild.reload
                 parent1.reload
                 parent2.reload
+                assert_equal [parent1.id, lft1,     lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [parent1.id, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [parent2.id, lft2,     lft2 + 5], [parent2.root_id, parent2.lft, parent2.rgt]
-                assert_equal [parent2.id, 1, 6], [parent2.root_id, parent2.lft, parent2.rgt]
+                assert_equal [parent2.id, lft2 + 1, lft2 + 4], [child.root_id, child.lft, child.rgt]
-                assert_equal [parent2.id, 2, 5], [child.root_id, child.lft, child.rgt]
+                assert_equal [parent2.id, lft2 + 2, lft2 + 3], [grandchild.root_id, grandchild.lft, grandchild.rgt]
-                assert_equal [parent2.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_move_a_child_with_descendants_to_another_project
+                lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 child.reload
                 child.project = Project.find(2)
                 assert child.save
                 child.reload
                 grandchild.reload
                 parent1.reload
+                assert_equal [1, parent1.id, lft1, lft1 + 1], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [1, parent1.id, 1, 2], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
                 assert_equal [2, child.id, 1, 4], [child.project_id, child.root_id, child.lft, child.rgt]
                 assert_equal [2, child.id, 2, 3], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
               def test_moving_an_issue_to_a_descendant_should_not_validate
                 parent1 = Issue.generate!
                 parent2 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id)
                 child.reload
                 child.parent_issue_id = grandchild.id
                 assert !child.save
                 assert_not_equal [], child.errors[:parent_issue_id]
               end
               def test_updating_a_root_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_updating_a_child_issue_should_not_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).never
                 issue.save!
               end
               def test_moving_a_root_issue_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!.id)
                 issue.parent_issue_id = "1"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_another_parent_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = "2"
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_moving_a_child_issue_to_root_should_trigger_update_nested_set_attributes_on_parent_change
                 issue = Issue.find(Issue.generate!(:parent_issue_id => 1).id)
                 issue.parent_issue_id = ""
                 issue.expects(:update_nested_set_attributes_on_parent_change).once
                 issue.save!
               end
               def test_destroy_should_destroy_children
+                lft1 = new_issue_lft
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue3 = Issue.generate!(:parent_issue_id => issue2.id)
                 issue4 = Issue.generate!(:parent_issue_id => issue1.id)
                 issue3.init_journal(User.find(2))
                 issue3.subject = 'child with journal'
                 issue3.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(issue2.id).destroy
                     end
                   end
                 end
                 issue1.reload
                 issue4.reload
                 assert !Issue.exists?(issue2.id)
                 assert !Issue.exists?(issue3.id)
-                assert_equal [issue1.id, 1, 4], [issue1.root_id, issue1.lft, issue1.rgt]
+                assert_equal [issue1.id, lft1,     lft1 + 3], [issue1.root_id, issue1.lft, issue1.rgt]
-                assert_equal [issue1.id, 2, 3], [issue4.root_id, issue4.lft, issue4.rgt]
+                assert_equal [issue1.id, lft1 + 1, lft1 + 2], [issue4.root_id, issue4.lft, issue4.rgt]
               end
               def test_destroy_child_should_update_parent
+                lft1 = new_issue_lft
                 issue = Issue.generate!
                 child1 = Issue.generate!(:parent_issue_id => issue.id)
                 child2 = Issue.generate!(:parent_issue_id => issue.id)
                 issue.reload
-                assert_equal [issue.id, 1, 6], [issue.root_id, issue.lft, issue.rgt]
+                assert_equal [issue.id, lft1, lft1 + 5], [issue.root_id, issue.lft, issue.rgt]
                 child2.reload.destroy
                 issue.reload
-                assert_equal [issue.id, 1, 4], [issue.root_id, issue.lft, issue.rgt]
+                assert_equal [issue.id, lft1, lft1 + 3], [issue.root_id, issue.lft, issue.rgt]
               end
               def test_destroy_parent_issue_updated_during_children_destroy
                 parent = Issue.generate!
                 Issue.generate!(:start_date => Date.today, :parent_issue_id => parent.id)
                 Issue.generate!(:start_date => 2.days.from_now, :parent_issue_id => parent.id)
                 assert_difference 'Issue.count', -3 do
                   Issue.find(parent.id).destroy
                 end
               end
               def test_destroy_child_issue_with_children
                 root = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'root')
                 child = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'child', :parent_issue_id => root.id)
                 leaf = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'leaf', :parent_issue_id => child.id)
                 leaf.init_journal(User.find(2))
                 leaf.subject = 'leaf with journal'
                 leaf.save!
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'Journal.count', -1 do
                     assert_difference 'JournalDetail.count', -1 do
                       Issue.find(child.id).destroy
                     end
                   end
                 end
                 root = Issue.find(root.id)
                 assert root.leaf?, "Root issue is not a leaf (lft: #{root.lft}, rgt: #{root.rgt})"
               end
               def test_destroy_issue_with_grand_child
+                lft1 = new_issue_lft
                 parent = Issue.generate!
                 issue = Issue.generate!(:parent_issue_id => parent.id)
                 child = Issue.generate!(:parent_issue_id => issue.id)
                 grandchild1 = Issue.generate!(:parent_issue_id => child.id)
                 grandchild2 = Issue.generate!(:parent_issue_id => child.id)
                 assert_difference 'Issue.count', -4 do
                   Issue.find(issue.id).destroy
                   parent.reload
-                  assert_equal [1, 2], [parent.lft, parent.rgt]
+                  assert_equal [lft1, lft1 + 1], [parent.lft, parent.rgt]
                 end
               end
               def test_parent_priority_should_be_the_highest_child_priority
                 parent = Issue.generate!(:priority => IssuePriority.find_by_name('Normal'))
                 # Create children
                 child1 = Issue.generate!(:priority => IssuePriority.find_by_name('High'), :parent_issue_id => parent.id)
                 assert_equal 'High', parent.reload.priority.name
                 child2 = Issue.generate!(:priority => IssuePriority.find_by_name('Immediate'), :parent_issue_id => child1.id)
                 assert_equal 'Immediate', child1.reload.priority.name
                 assert_equal 'Immediate', parent.reload.priority.name
                 child3 = Issue.generate!(:priority => IssuePriority.find_by_name('Low'), :parent_issue_id => parent.id)
                 assert_equal 'Immediate', parent.reload.priority.name
                 # Destroy a child
                 child1.destroy
                 assert_equal 'Low', parent.reload.priority.name
                 # Update a child
                 child3.reload.priority = IssuePriority.find_by_name('Normal')
                 child3.save!
                 assert_equal 'Normal', parent.reload.priority.name
               end
               def test_parent_dates_should_be_lowest_start_and_highest_due_dates
                 parent = Issue.generate!
                 Issue.generate!(:start_date => '2010-01-25', :due_date => '2010-02-15', :parent_issue_id => parent.id)
                 Issue.generate!(                             :due_date => '2010-02-13', :parent_issue_id => parent.id)
                 Issue.generate!(:start_date => '2010-02-01', :due_date => '2010-02-22', :parent_issue_id => parent.id)
                 parent.reload
                 assert_equal Date.parse('2010-01-25'), parent.start_date
                 assert_equal Date.parse('2010-02-22'), parent.due_date
               end
               def test_parent_done_ratio_should_be_average_done_ratio_of_leaves
                 parent = Issue.generate!
                 Issue.generate!(:done_ratio => 20, :parent_issue_id => parent.id)
                 assert_equal 20, parent.reload.done_ratio
                 Issue.generate!(:done_ratio => 70, :parent_issue_id => parent.id)
                 assert_equal 45, parent.reload.done_ratio
                 child = Issue.generate!(:done_ratio => 0, :parent_issue_id => parent.id)
                 assert_equal 30, parent.reload.done_ratio
                 Issue.generate!(:done_ratio => 30, :parent_issue_id => child.id)
                 assert_equal 30, child.reload.done_ratio
                 assert_equal 40, parent.reload.done_ratio
               end
               def test_parent_done_ratio_should_be_weighted_by_estimated_times_if_any
                 parent = Issue.generate!
                 Issue.generate!(:estimated_hours => 10, :done_ratio => 20, :parent_issue_id => parent.id)
                 assert_equal 20, parent.reload.done_ratio
                 Issue.generate!(:estimated_hours => 20, :done_ratio => 50, :parent_issue_id => parent.id)
                 assert_equal (50 * 20 + 20 * 10) / 30, parent.reload.done_ratio
               end
               def test_parent_done_ratio_with_child_estimate_to_0_should_reach_100
                 parent = Issue.generate!
                 issue1 = Issue.generate!(:parent_issue_id => parent.id)
                 issue2 = Issue.generate!(:parent_issue_id => parent.id, :estimated_hours => 0)
                 assert_equal 0, parent.reload.done_ratio
                 issue1.reload.update_attribute :status_id, 5
                 assert_equal 50, parent.reload.done_ratio
                 issue2.reload.update_attribute :status_id, 5
                 assert_equal 100, parent.reload.done_ratio
               end
               def test_parent_estimate_should_be_sum_of_leaves
                 parent = Issue.generate!
                 Issue.generate!(:estimated_hours => nil, :parent_issue_id => parent.id)
                 assert_equal nil, parent.reload.estimated_hours
                 Issue.generate!(:estimated_hours => 5, :parent_issue_id => parent.id)
                 assert_equal 5, parent.reload.estimated_hours
                 Issue.generate!(:estimated_hours => 7, :parent_issue_id => parent.id)
                 assert_equal 12, parent.reload.estimated_hours
               end
               def test_move_parent_updates_old_parent_attributes
                 first_parent = Issue.generate!
                 second_parent = Issue.generate!
                 child = Issue.generate!(:estimated_hours => 5, :parent_issue_id => first_parent.id)
                 assert_equal 5, first_parent.reload.estimated_hours
                 child.update_attributes(:estimated_hours => 7, :parent_issue_id => second_parent.id)
                 assert_equal 7, second_parent.reload.estimated_hours
                 assert_nil first_parent.reload.estimated_hours
               end
               def test_reschuling_a_parent_should_reschedule_subtasks
                 parent = Issue.generate!
                 c1 = Issue.generate!(:start_date => '2010-05-12', :due_date => '2010-05-18', :parent_issue_id => parent.id)
                 c2 = Issue.generate!(:start_date => '2010-06-03', :due_date => '2010-06-10', :parent_issue_id => parent.id)
                 parent.reload
                 parent.reschedule_on!(Date.parse('2010-06-02'))
                 c1.reload
                 assert_equal [Date.parse('2010-06-02'), Date.parse('2010-06-08')], [c1.start_date, c1.due_date]
                 c2.reload
                 assert_equal [Date.parse('2010-06-03'), Date.parse('2010-06-10')], [c2.start_date, c2.due_date] # no change
                 parent.reload
                 assert_equal [Date.parse('2010-06-02'), Date.parse('2010-06-10')], [parent.start_date, parent.due_date]
               end
               def test_project_copy_should_copy_issue_tree
                 p = Project.create!(:name => 'Tree copy', :identifier => 'tree-copy', :tracker_ids => [1, 2])
                 i1 = Issue.generate!(:project => p, :subject => 'i1')
                 i2 = Issue.generate!(:project => p, :subject => 'i2', :parent_issue_id => i1.id)
                 i3 = Issue.generate!(:project => p, :subject => 'i3', :parent_issue_id => i1.id)
                 i4 = Issue.generate!(:project => p, :subject => 'i4', :parent_issue_id => i2.id)
                 i5 = Issue.generate!(:project => p, :subject => 'i5')
                 c = Project.new(:name => 'Copy', :identifier => 'copy', :tracker_ids => [1, 2])
                 c.copy(p, :only => 'issues')
                 c.reload
                 assert_equal 5, c.issues.count
                 ic1, ic2, ic3, ic4, ic5 = c.issues.order('subject').all
                 assert ic1.root?
                 assert_equal ic1, ic2.parent
                 assert_equal ic1, ic3.parent
                 assert_equal ic2, ic4.parent
                 assert ic5.root?
               end
             end

test/unit/issue_transaction_test.rb +5 -7

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 IssueTransactionTest < ActiveSupport::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles,
                        :trackers, :projects_trackers,
                        :versions,
                        :issue_statuses, :issue_categories, :issue_relations, :workflows,
                        :enumerations,
                        :issues,
                        :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                        :time_entries
               self.use_transactional_fixtures = false
               def test_invalid_move_to_another_project
+                lft1 = new_issue_lft
                 parent1 = Issue.generate!
                 child =   Issue.generate!(:parent_issue_id => parent1.id)
                 grandchild = Issue.generate!(:parent_issue_id => child.id, :tracker_id => 2)
                 Project.find(2).tracker_ids = [1]
                 parent1.reload
-                assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [1, parent1.id, lft1, lft1 + 5], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
                 # child can not be moved to Project 2 because its child is on a disabled tracker
                 child = Issue.find(child.id)
                 child.project = Project.find(2)
                 assert !child.save
                 child.reload
                 grandchild.reload
                 parent1.reload
                 # no change
-                assert_equal [1, parent1.id, 1, 6], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
+                assert_equal [1, parent1.id, lft1,     lft1 + 5], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
-                assert_equal [1, parent1.id, 2, 5], [child.project_id, child.root_id, child.lft, child.rgt]
+                assert_equal [1, parent1.id, lft1 + 1, lft1 + 4], [child.project_id, child.root_id, child.lft, child.rgt]
-                assert_equal [1, parent1.id, 3, 4], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]
+                assert_equal [1, parent1.id, lft1 + 2, lft1 + 3], [grandchild.project_id, grandchild.root_id, grandchild.lft, grandchild.rgt]
               end
             end

test/unit/mail_handler_test.rb +4 -2

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2013  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
+                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, 1, 2], [issue.root_id, issue.lft, issue.rgt]
+                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?('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_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
+                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, 1, 2], [issue.root_id, issue.lft, issue.rgt]
+                    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_same_elements [group1, group2], user.groups
               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
                 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_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"
                 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_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..."
                 str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
                 assert_kind_of Issue, issue
                 assert_equal str, 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_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."
                 if !kr.respond_to?(:force_encoding)
                   puts "\nOn Ruby 1.8, skip Korean encoding mail body test"
                 else
                   kr.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
               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 false, journal.private_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.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_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"
                 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
               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
               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