jro_apps/redmine Commit - r8972:df89c24e37af

Adds an helper to get the body of an email in tests....

Jean-Philippe Lang -

r8972:df89c24e37af

parent child

Context file:

r8972:df89c24e37af

Collapse all files

test/test_helper.rb +8 -4

              # Redmine - project management software
              # Copyright (C) 2006-2011  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.
              ENV["RAILS_ENV"] = "test"
              require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
              require 'test_help'
              require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
              require File.expand_path(File.dirname(__FILE__) + '/object_daddy_helpers')
              include ObjectDaddyHelpers
              class ActiveSupport::TestCase
                # Transactional fixtures accelerate your tests by wrapping each test method
                # in a transaction that's rolled back on completion.  This ensures that the
                # test database remains unchanged so your fixtures don't have to be reloaded
                # between every test method.  Fewer database queries means faster tests.
                #
                # Read Mike Clark's excellent walkthrough at
                #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
                #
                # Every Active Record database supports transactions except MyISAM tables
                # in MySQL.  Turn off transactional fixtures in this case; however, if you
                # don't care one way or the other, switching from MyISAM to InnoDB tables
                # is recommended.
                self.use_transactional_fixtures = true
                # Instantiated fixtures are slow, but give you @david where otherwise you
                # would need people(:david).  If you don't want to migrate your existing
                # test cases which use the @david style and don't mind the speed hit (each
                # instantiated fixtures translates to a database query per test method),
                # then set this back to true.
                self.use_instantiated_fixtures  = false
                # Add more helper methods to be used by all tests here...
                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)
                  ActionController::TestUploadedFile.new(
                    ActiveSupport::TestCase.fixture_path + "/files/#{name}", mime, true)
                end
                def credentials(user, password=nil)
                  {: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({}) {|h, k| h[k] = Setting[k].is_a?(Symbol) ? Setting[k] : Setting[k].dup; h}
                  options.each {|k, v| Setting[k] = v}
                  yield
                ensure
                  saved_settings.each {|k, v| Setting[k] = v} if saved_settings
                end
                def change_user_password(login, new_password)
                  user = User.first(:conditions => {:login => login})
                  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
                # 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
                  hs
                end
                def assert_error_tag(options={})
                  assert_tag({:attributes => { :id => 'errorExplanation' }}.merge(options))
                end
                def assert_include(expected, s)
                  assert s.include?(expected), "\"#{expected}\" not found in \"#{s}\""
                end
                def assert_not_include(expected, s)
                  assert !s.include?(expected), "\"#{expected}\" found in \"#{s}\""
                end
                def assert_mail_body_match(expected, mail)
                  if expected.is_a?(String)
-                   assert_include expected, mail.body
+                   assert_include expected, mail_body(mail)
                  else
-                   assert_match expected, mail.body
+                   assert_match expected, mail_body(mail)
                  end
                end
                def assert_mail_body_no_match(expected, mail)
                  if expected.is_a?(String)
-                   assert_not_include expected, mail.body
+                   assert_not_include expected, mail_body(mail)
                  else
-                   assert_no_match expected, mail.body
+                   assert_no_match expected, mail_body(mail)
                  end
                end
+               def mail_body(mail)
+                 mail.body
+               end
                # Shoulda macros
                def self.should_render_404
                  should_respond_with :not_found
                  should_render_template 'common/error'
                end
                def self.should_have_before_filter(expected_method, options = {})
                  should_have_filter('before', expected_method, options)
                end
                def self.should_have_after_filter(expected_method, options = {})
                  should_have_filter('after', expected_method, options)
                end
                def self.should_have_filter(filter_type, expected_method, options)
                  description = "have #{filter_type}_filter :#{expected_method}"
                  description << " with #{options.inspect}" unless options.empty?
                  should description do
                    klass = "action_controller/filters/#{filter_type}_filter".classify.constantize
                    expected = klass.new(:filter, expected_method.to_sym, options)
                    assert_equal 1, @controller.class.filter_chain.select { |filter|
                      filter.method == expected.method && filter.kind == expected.kind &&
                      filter.options == expected.options && filter.class == expected.class
                    }.size
                  end
                end
                def self.should_show_the_old_and_new_values_for(prop_key, model, &block)
                  context "" do
                    setup do
                      if block_given?
                        instance_eval &block
                      else
                        @old_value = model.generate!
                        @new_value = model.generate!
                      end
                    end
                    should "use the new value's name" do
                      @detail = JournalDetail.generate!(:property => 'attr',
                                                        :old_value => @old_value.id,
                                                        :value => @new_value.id,
                                                        :prop_key => prop_key)
                      assert_match @new_value.name, show_detail(@detail, true)
                    end
                    should "use the old value's name" do
                      @detail = JournalDetail.generate!(:property => 'attr',
                                                        :old_value => @old_value.id,
                                                        :value => @new_value.id,
                                                        :prop_key => prop_key)
                      assert_match @old_value.name, show_detail(@detail, true)
                    end
                  end
                end
                # 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_with_protected!(:password => 'my_password', :password_confirmation => 'my_password', :admin => true) # Admin so they can access the project
                        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_with_protected!
                        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_with_protected!(:admin => true)
                        @token = Token.generate!(: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_with_protected!
                        @token = Token.generate!(: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_with_protected!(:admin => true)
                        @token = Token.generate!(: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_with_protected!
                        @token = Token.generate!(: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_with_protected!(:admin => true)
                      @token = Token.generate!(: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_content_type :xml
                  when url.match(/json/i)
                    should_respond_with_content_type :json
                  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
              end
              # Simple module to "namespace" all of the API tests
              module ApiTest
              end

test/unit/lib/redmine/hook_test.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2011  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 Redmine::Hook::ManagerTest < ActiveSupport::TestCase
                fixtures :issues
                # Some hooks that are manually registered in these tests
                class TestHook < Redmine::Hook::ViewListener; end
                class TestHook1 < TestHook
                  def view_layouts_base_html_head(context)
                    'Test hook 1 listener.'
                  end
                end
                class TestHook2 < TestHook
                  def view_layouts_base_html_head(context)
                    'Test hook 2 listener.'
                  end
                end
                class TestHook3 < TestHook
                  def view_layouts_base_html_head(context)
                    "Context keys: #{context.keys.collect(&:to_s).sort.join(', ')}."
                  end
                end
                class TestLinkToHook < TestHook
                  def view_layouts_base_html_head(context)
                    link_to('Issues', :controller => 'issues')
                  end
                end
                class TestHookHelperController < ActionController::Base
                  include Redmine::Hook::Helper
                end
                class TestHookHelperView < ActionView::Base
                  include Redmine::Hook::Helper
                end
                Redmine::Hook.clear_listeners
                def setup
                  @hook_module = Redmine::Hook
                end
                def teardown
                  @hook_module.clear_listeners
                end
                def test_clear_listeners
                  assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                  @hook_module.add_listener(TestHook1)
                  @hook_module.add_listener(TestHook2)
                  assert_equal 2, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                  @hook_module.clear_listeners
                  assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                end
                def test_add_listener
                  assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                  @hook_module.add_listener(TestHook1)
                  assert_equal 1, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                end
                def test_call_hook
                  @hook_module.add_listener(TestHook1)
                  assert_equal ['Test hook 1 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
                end
                def test_call_hook_with_context
                  @hook_module.add_listener(TestHook3)
                  assert_equal ['Context keys: bar, controller, foo, project, request.'],
                               hook_helper.call_hook(:view_layouts_base_html_head, :foo => 1, :bar => 'a')
                end
                def test_call_hook_with_multiple_listeners
                  @hook_module.add_listener(TestHook1)
                  @hook_module.add_listener(TestHook2)
                  assert_equal ['Test hook 1 listener.', 'Test hook 2 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
                end
                # Context: Redmine::Hook::Helper.call_hook default_url
                def test_call_hook_default_url_options
                  @hook_module.add_listener(TestLinkToHook)
                  assert_equal ['<a href="/issues">Issues</a>'], hook_helper.call_hook(:view_layouts_base_html_head)
                end
                # Context: Redmine::Hook::Helper.call_hook
                def test_call_hook_with_project_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /project/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
                end
                def test_call_hook_from_controller_with_controller_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /controller/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
                end
                def test_call_hook_from_controller_with_request_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /request/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
                end
                def test_call_hook_from_view_with_project_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /project/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
                end
                def test_call_hook_from_view_with_controller_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /controller/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
                end
                def test_call_hook_from_view_with_request_added_to_context
                  @hook_module.add_listener(TestHook3)
                  assert_match /request/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
                end
                def test_call_hook_from_view_should_join_responses_with_a_space
                  @hook_module.add_listener(TestHook1)
                  @hook_module.add_listener(TestHook2)
                  assert_equal 'Test hook 1 listener. Test hook 2 listener.',
                               view_hook_helper.call_hook(:view_layouts_base_html_head)
                end
                def test_call_hook_should_not_change_the_default_url_for_email_notifications
                  issue = Issue.find(1)
                  ActionMailer::Base.deliveries.clear
                  Mailer.deliver_issue_add(issue)
                  mail = ActionMailer::Base.deliveries.last
                  @hook_module.add_listener(TestLinkToHook)
                  hook_helper.call_hook(:view_layouts_base_html_head)
                  ActionMailer::Base.deliveries.clear
                  Mailer.deliver_issue_add(issue)
                  mail2 = ActionMailer::Base.deliveries.last
-                 assert_equal mail.body, mail2.body
+                 assert_equal mail_body(mail), mail_body(mail2)
                end
                def hook_helper
                  @hook_helper ||= TestHookHelperController.new
                end
                def view_hook_helper
                  @view_hook_helper ||= TestHookHelperView.new(Rails.root.to_s + '/app/views')
                end
              end

test/unit/mail_handler_test.rb +2 -2

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2011  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 test_add_issue
                  ActionMailer::Base.deliveries.clear
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal issue.project.trackers.first, issue.tracker
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal IssueStatus.find_by_name('Resolved'), issue.status
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal Version.find_by_name('Alpha'), issue.fixed_version
                  assert_equal 2.5, issue.estimated_hours
                  assert_equal 30, issue.done_ratio
                  assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                  # keywords should be removed from the email body
                  assert !issue.description.match(/^Project:/i)
                  assert !issue.description.match(/^Status:/i)
                  assert !issue.description.match(/^Start Date:/i)
                  # Email notification should be sent
                  mail = ActionMailer::Base.deliveries.last
                  assert_not_nil mail
                  assert mail.subject.include?('New ticket on a given project')
                end
                def test_add_issue_with_default_tracker
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email(
                            'ticket_on_given_project.eml',
                            :issue => {:tracker => 'Support request'}
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Support request', issue.tracker.name
                end
                def test_add_issue_with_status
                  # This email contains: 'Project: onlinestore' and 'Status: Resolved'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal Project.find(2), issue.project
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                end
                def test_add_issue_with_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_group_assignment
                  with_settings :issue_group_assignment => '1' do
                    issue = submit_email('ticket_on_given_project.eml') do |email|
                      email.gsub!('Assigned to: John Smith', 'Assigned to: B Team')
                    end
                    assert issue.is_a?(Issue)
                    assert !issue.new_record?
                    issue.reload
                    assert_equal Group.find(11), issue.assigned_to
                  end
                end
                def test_add_issue_with_partial_attributes_override
                  issue = submit_email(
                            'ticket_with_attributes.eml',
                            :issue => {:priority => 'High'},
                            :allow_override => ['tracker']
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_nil issue.category
                  assert_equal 'High', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_spaces_between_attribute_and_separator
                  issue = submit_email(
                            'ticket_with_spaces_between_attribute_and_separator.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_attachment_to_specific_project
                  issue = submit_email('ticket_with_attachment.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'Ticket created by email with attachment', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'This is  a new ticket with attachments', issue.description
                  # Attachment properties
                  assert_equal 1, issue.attachments.size
                  assert_equal 'Paella.jpg', issue.attachments.first.filename
                  assert_equal 'image/jpeg', issue.attachments.first.content_type
                  assert_equal 10790, issue.attachments.first.filesize
                end
                def test_add_issue_with_custom_fields
                  issue = submit_email('ticket_with_custom_fields.eml', :issue => {:project => 'onlinestore'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket with custom field values', issue.subject
                  assert_equal 'Value for a custom field',
                               issue.custom_value_for(CustomField.find_by_name('Searchable field')).value
                  assert !issue.description.match(/^searchable field:/i)
                end
                def test_add_issue_with_cc
                  issue = submit_email('ticket_with_cc.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert issue.watched_by?(User.find_by_mail('dlopper@somenet.foo'))
                  assert_equal 1, issue.watcher_user_ids.size
                end
                def test_add_issue_by_unknown_user
                  assert_no_difference 'User.count' do
                    assert_equal false,
                                 submit_email(
                                   'ticket_by_unknown_user.eml',
                                   :issue => {:project => 'ecookbook'}
                                 )
                  end
                end
                def test_add_issue_by_anonymous_user
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_unknown_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'accept'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.anonymous?
                  end
                end
                def test_add_issue_by_anonymous_user_with_no_from_address
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_empty_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'accept'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.anonymous?
                  end
                end
                def test_add_issue_by_anonymous_user_on_private_project
                  Role.anonymous.add_permission!(:add_issues)
                  assert_no_difference 'User.count' do
                    assert_no_difference 'Issue.count' do
                      assert_equal false,
                                   submit_email(
                                     'ticket_by_unknown_user.eml',
                                     :issue => {:project => 'onlinestore'},
                                     :unknown_user => 'accept'
                                   )
                    end
                  end
                end
                def test_add_issue_by_anonymous_user_on_private_project_without_permission_check
                  assert_no_difference 'User.count' do
                    assert_difference 'Issue.count' do
                      issue = submit_email(
                                'ticket_by_unknown_user.eml',
                                :issue => {:project => 'onlinestore'},
                                :no_permission_check => '1',
                                :unknown_user => 'accept'
                              )
                      assert issue.is_a?(Issue)
                      assert issue.author.anonymous?
                      assert !issue.project.is_public?
                      assert_equal [issue.id, 1, 2], [issue.root_id, issue.lft, issue.rgt]
                    end
                  end
                end
                def test_add_issue_by_created_user
                  Setting.default_language = 'en'
                  assert_difference 'User.count' do
                    issue = submit_email(
                              'ticket_by_unknown_user.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'create'
                            )
                    assert issue.is_a?(Issue)
                    assert issue.author.active?
                    assert_equal 'john.doe@somenet.foo', issue.author.mail
                    assert_equal 'John', issue.author.firstname
                    assert_equal 'Doe', issue.author.lastname
                    # account information
                    email = ActionMailer::Base.deliveries.first
                    assert_not_nil email
                    assert email.subject.include?('account activation')
-                   login = email.body.match(/\* Login: (.*)$/)[1]
-                   password = email.body.match(/\* Password: (.*)$/)[1]
+                   login = mail_body(email).match(/\* Login: (.*)$/)[1]
+                   password = mail_body(email).match(/\* Password: (.*)$/)[1]
                    assert_equal issue.author, User.try_to_login(login, password)
                  end
                end
                def test_add_issue_without_from_header
                  Role.anonymous.add_permission!(:add_issues)
                  assert_equal false, submit_email('ticket_without_from_header.eml')
                end
                def test_add_issue_with_invalid_attributes
                  issue = submit_email(
                            'ticket_with_invalid_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_nil issue.assigned_to
                  assert_nil issue.start_date
                  assert_nil issue.due_date
                  assert_equal 0, issue.done_ratio
                  assert_equal 'Normal', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_localized_attributes
                  User.find_by_mail('jsmith@somenet.foo').update_attribute 'language', 'fr'
                  issue = submit_email(
                            'ticket_with_localized_attributes.eml',
                            :allow_override => 'tracker,category,priority'
                          )
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'New ticket on a given project', issue.subject
                  assert_equal User.find_by_login('jsmith'), issue.author
                  assert_equal Project.find(2), issue.project
                  assert_equal 'Feature request', issue.tracker.to_s
                  assert_equal 'Stock management', issue.category.to_s
                  assert_equal 'Urgent', issue.priority.to_s
                  assert issue.description.include?('Lorem ipsum dolor sit amet, consectetuer adipiscing elit.')
                end
                def test_add_issue_with_japanese_keywords
                  ja_dev = "\xe9\x96\x8b\xe7\x99\xba"
                  ja_dev.force_encoding('UTF-8') if ja_dev.respond_to?(:force_encoding)
                  tracker = Tracker.create!(:name => ja_dev)
                  Project.find(1).trackers << tracker
                  issue = submit_email(
                            'japanese_keywords_iso_2022_jp.eml',
                            :issue => {:project => 'ecookbook'},
                            :allow_override => 'tracker'
                          )
                  assert_kind_of Issue, issue
                  assert_equal tracker, issue.tracker
                end
                def test_add_issue_from_apple_mail
                  issue = submit_email(
                            'apple_mail_with_attachment.eml',
                            :issue => {:project => 'ecookbook'}
                          )
                  assert_kind_of Issue, issue
                  assert_equal 1, issue.attachments.size
                  attachment = issue.attachments.first
                  assert_equal 'paella.jpg', attachment.filename
                  assert_equal 10790, attachment.filesize
                  assert File.exist?(attachment.diskfile)
                  assert_equal 10790, File.size(attachment.diskfile)
                  assert_equal 'caaf384198bcbc9563ab5c058acd73cd', attachment.digest
                end
                def test_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_add_issue_should_send_email_notification
                  Setting.notified_events = ['issue_added']
                  ActionMailer::Base.deliveries.clear
                  # This email contains: 'Project: onlinestore'
                  issue = submit_email('ticket_on_given_project.eml')
                  assert issue.is_a?(Issue)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                end
                def test_update_issue_with_attribute_changes
                  # This email contains: 'Status: Resolved'
                  journal = submit_email('ticket_reply_with_status.eml')
                  assert journal.is_a?(Journal)
                  issue = Issue.find(journal.issue.id)
                  assert_equal User.find_by_login('jsmith'), journal.user
                  assert_equal Issue.find(2), journal.journalized
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal IssueStatus.find_by_name("Resolved"), issue.status
                  assert_equal '2010-01-01', issue.start_date.to_s
                  assert_equal '2010-12-31', issue.due_date.to_s
                  assert_equal User.find_by_login('jsmith'), issue.assigned_to
                  assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value
                  # keywords should be removed from the email body
                  assert !journal.notes.match(/^Status:/i)
                  assert !journal.notes.match(/^Start Date:/i)
                end
                def test_update_issue_with_attachment
                  assert_difference 'Journal.count' do
                    assert_difference 'JournalDetail.count' do
                      assert_difference 'Attachment.count' do
                        assert_no_difference 'Issue.count' do
                          journal = submit_email('ticket_with_attachment.eml') do |raw|
                            raw.gsub! /^Subject: .*$/, 'Subject: Re: [Cookbook - Feature #2] (New) Add ingredients categories'
                          end
                        end
                      end
                    end
                  end
                  journal = Journal.first(:order => 'id DESC')
                  assert_equal Issue.find(2), journal.journalized
                  assert_equal 1, journal.details.size
                  detail = journal.details.first
                  assert_equal 'attachment', detail.property
                  assert_equal 'Paella.jpg', detail.value
                end
                def test_update_issue_should_send_email_notification
                  ActionMailer::Base.deliveries.clear
                  journal = submit_email('ticket_reply.eml')
                  assert journal.is_a?(Journal)
                  assert_equal 1, ActionMailer::Base.deliveries.size
                end
                def test_update_issue_should_not_set_defaults
                  journal = submit_email(
                              'ticket_reply.eml',
                              :issue => {:tracker => 'Support request', :priority => 'High'}
                            )
                  assert journal.is_a?(Journal)
                  assert_match /This is reply/, journal.notes
                  assert_equal 'Feature request', journal.issue.tracker.name
                  assert_equal 'Normal', journal.issue.priority.name
                end
                def test_reply_to_a_message
                  m = submit_email('message_reply.eml')
                  assert m.is_a?(Message)
                  assert !m.new_record?
                  m.reload
                  assert_equal 'Reply via email', m.subject
                  # The email replies to message #2 which is part of the thread of message #1
                  assert_equal Message.find(1), m.parent
                end
                def test_reply_to_a_message_by_subject
                  m = submit_email('message_reply_by_subject.eml')
                  assert m.is_a?(Message)
                  assert !m.new_record?
                  m.reload
                  assert_equal 'Reply to the first post', m.subject
                  assert_equal Message.find(1), m.parent
                end
                def test_should_strip_tags_of_html_only_emails
                  issue = submit_email('ticket_html_only.eml', :issue => {:project => 'ecookbook'})
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                  assert_equal 'HTML email', issue.subject
                  assert_equal 'This is a html-only email.', issue.description
                end
                context "truncate emails based on the Setting" do
                  context "with no setting" do
                    setup do
                      Setting.mail_handler_body_delimiters = ''
                    end
                    should "add the entire email into the issue" do
                      issue = submit_email('ticket_on_given_project.eml')
                      assert_issue_created(issue)
                      assert issue.description.include?('---')
                      assert issue.description.include?('This paragraph is after the delimiter')
                    end
                  end
                  context "with a single string" do
                    setup do
                      Setting.mail_handler_body_delimiters = '---'
                    end
                    should "truncate the email at the delimiter for the issue" do
                      issue = submit_email('ticket_on_given_project.eml')
                      assert_issue_created(issue)
                      assert issue.description.include?('This paragraph is before delimiters')
                      assert issue.description.include?('--- This line starts with a delimiter')
                      assert !issue.description.match(/^---$/)
                      assert !issue.description.include?('This paragraph is after the delimiter')
                    end
                  end
                  context "with a single quoted reply (e.g. reply to a Redmine email notification)" do
                    setup do
                      Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
                    end
                    should "truncate the email at the delimiter with the quoted reply symbols (>)" do
                      journal = submit_email('issue_update_with_quoted_reply_above.eml')
                      assert journal.is_a?(Journal)
                      assert journal.notes.include?('An update to the issue by the sender.')
                      assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
                      assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                    end
                  end
                  context "with multiple quoted replies (e.g. reply to a reply of a Redmine email notification)" do
                    setup do
                      Setting.mail_handler_body_delimiters = '--- Reply above. Do not remove this line. ---'
                    end
                    should "truncate the email at the delimiter with the quoted reply symbols (>)" do
                      journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')
                      assert journal.is_a?(Journal)
                      assert journal.notes.include?('An update to the issue by the sender.')
                      assert !journal.notes.match(Regexp.escape("--- Reply above. Do not remove this line. ---"))
                      assert !journal.notes.include?('Looks like the JSON api for projects was missed.')
                    end
                  end
                  context "with multiple strings" do
                    setup do
                      Setting.mail_handler_body_delimiters = "---\nBREAK"
                    end
                    should "truncate the email at the first delimiter found (BREAK)" do
                      issue = submit_email('ticket_on_given_project.eml')
                      assert_issue_created(issue)
                      assert issue.description.include?('This paragraph is before delimiters')
                      assert !issue.description.include?('BREAK')
                      assert !issue.description.include?('This paragraph is between delimiters')
                      assert !issue.description.match(/^---$/)
                      assert !issue.description.include?('This paragraph is after the delimiter')
                    end
                  end
                end
                def test_email_with_long_subject_line
                  issue = submit_email('ticket_with_long_subject.eml')
                  assert issue.is_a?(Issue)
                  assert_equal issue.subject, 'New ticket on a given project with a very long subject line which exceeds 255 chars and should not be ignored but chopped off. And if the subject line is still not long enough, we just add more text. And more text. Wow, this is really annoying. Especially, if you have nothing to say...'[0,255]
                end
                def test_new_user_from_attributes_should_return_valid_user
                  to_test = {
                    # [address, name] => [login, firstname, lastname]
                    ['jsmith@example.net', nil] => ['jsmith@example.net', 'jsmith', '-'],
                    ['jsmith@example.net', 'John'] => ['jsmith@example.net', 'John', '-'],
                    ['jsmith@example.net', 'John Smith'] => ['jsmith@example.net', 'John', 'Smith'],
                    ['jsmith@example.net', 'John Paul Smith'] => ['jsmith@example.net', 'John', 'Paul Smith'],
                    ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsTheMaximumLength Smith'] => ['jsmith@example.net', 'AVeryLongFirstnameThatExceedsT', 'Smith'],
                    ['jsmith@example.net', 'John AVeryLongLastnameThatExceedsTheMaximumLength'] => ['jsmith@example.net', 'John', 'AVeryLongLastnameThatExceedsTh']
                  }
                  to_test.each do |attrs, expected|
                    user = MailHandler.new_user_from_attributes(attrs.first, attrs.last)
                    assert user.valid?, user.errors.full_messages.to_s
                    assert_equal attrs.first, user.mail
                    assert_equal expected[0], user.login
                    assert_equal expected[1], user.firstname
                    assert_equal expected[2], user.lastname
                  end
                end
                def test_new_user_from_attributes_should_respect_minimum_password_length
                  with_settings :password_min_length => 15 do
                    user = MailHandler.new_user_from_attributes('jsmith@example.net')
                    assert user.valid?
                    assert user.password.length >= 15
                  end
                end
                def test_new_user_from_attributes_should_use_default_login_if_invalid
                  user = MailHandler.new_user_from_attributes('foo+bar@example.net')
                  assert user.valid?
                  assert user.login =~ /^user[a-f0-9]+$/
                  assert_equal 'foo+bar@example.net', user.mail
                end
                def test_new_user_with_utf8_encoded_fullname_should_be_decoded
                  assert_difference 'User.count' do
                    issue = submit_email(
                              'fullname_of_sender_as_utf8_encoded.eml',
                              :issue => {:project => 'ecookbook'},
                              :unknown_user => 'create'
                            )
                  end
                  user = User.first(:order => 'id DESC')
                  assert_equal "foo@example.org", user.mail
                  assert_equal "Ää", user.firstname
                  assert_equal "Öö", user.lastname
                end
                private
                def submit_email(filename, options={})
                  raw = IO.read(File.join(FIXTURES_PATH, filename))
                  yield raw if block_given?
                  MailHandler.receive(raw, options)
                end
                def assert_issue_created(issue)
                  assert issue.is_a?(Issue)
                  assert !issue.new_record?
                  issue.reload
                end
              end

General Comments 0

Write
Preview

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

No TODOs yet

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

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