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, 1, 2], [issue1.root_id, issue1.parent_id, issue1.lft, issue1.rgt]
-                 assert_equal [issue2.id, nil, 1, 2], [issue2.root_id, issue2.parent_id, issue2.lft, issue2.rgt]
+                 assert_equal [issue1.id, nil, lft1, lft1 + 1], [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]
                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, 1, 4], [parent.root_id, parent.parent_id, parent.lft, parent.rgt]
-                 assert_equal [parent.id, parent.id, 2, 3], [child.root_id, child.parent_id, child.lft, child.rgt]
+                 assert_equal [parent.id, nil,       lft,     lft + 3], [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]
                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, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
-                 assert_equal [parent1.id, 4, 5], [parent2.root_id, parent2.lft, parent2.rgt]
-                 assert_equal [parent1.id, 2, 3], [child.root_id, child.lft, child.rgt]
+                 assert_equal [parent1.id, lft,     lft + 5], [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, lft + 1, lft + 2], [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, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
-                 assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
+                 assert_equal [parent1.id, lft1, lft1 + 1], [parent1.root_id, parent1.lft, parent1.rgt]
+                 assert_equal [parent2.id, lft2, lft2 + 1], [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, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
-                 assert_equal [parent2.id, 1, 4], [parent2.root_id, parent2.lft, parent2.rgt]
-                 assert_equal [parent2.id, 2, 3], [child.root_id, child.lft, child.rgt]
+                 assert_equal [parent1.id, lft1,     lft1 + 1], [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, lft2 + 1, lft2 + 2], [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, 1, 6], [parent1.root_id, parent1.lft, parent1.rgt]
-                 assert_equal [parent2.id, 1, 2], [parent2.root_id, parent2.lft, parent2.rgt]
-                 assert_equal [parent1.id, 2, 5], [child.root_id, child.lft, child.rgt]
-                 assert_equal [parent1.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
+                 assert_equal [parent1.id, lft1,     lft1 + 5], [parent1.root_id, parent1.lft, parent1.rgt]
+                 assert_equal [parent2.id, lft2,     lft2 + 1], [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, lft1 + 2, lft1 + 3], [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, 1, 2], [parent1.root_id, parent1.lft, parent1.rgt]
-                 assert_equal [parent2.id, 1, 6], [parent2.root_id, parent2.lft, parent2.rgt]
-                 assert_equal [parent2.id, 2, 5], [child.root_id, child.lft, child.rgt]
-                 assert_equal [parent2.id, 3, 4], [grandchild.root_id, grandchild.lft, grandchild.rgt]
+                 assert_equal [parent1.id, lft1,     lft1 + 1], [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, lft2 + 1, lft2 + 4], [child.root_id, child.lft, child.rgt]
+                 assert_equal [parent2.id, lft2 + 2, lft2 + 3], [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, 1, 2], [parent1.project_id, parent1.root_id, parent1.lft, parent1.rgt]
+                 assert_equal [1, parent1.id, lft1, lft1 + 1], [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, 2, 3], [issue4.root_id, issue4.lft, issue4.rgt]
+                 assert_equal [issue1.id, lft1,     lft1 + 3], [issue1.root_id, issue1.lft, issue1.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, 2, 5], [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,     lft1 + 5], [parent1.project_id, parent1.root_id, parent1.lft, parent1.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, 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