jro_apps/redmine Commit - r13607:af5872b7d432

Support for accent insensitive search with PostgreSQL (#18801)....

Jean-Philippe Lang -

r13607:af5872b7d432

parent child

Context file:

r13607:af5872b7d432

Collapse all files

lib/redmine/database.rb created 644 +53 0

@@ -0,0 +1,53
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2015 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	module Redmine
	19	# Helper module to get information about the Redmine database
	20	module Database
	21	class << self
	22	# Returns true if the database is PostgreSQL
	23	def postgresql?
	24	(ActiveRecord::Base.connection.adapter_name =~ /postgresql/i).present?
	25	end
	26
	27	# Returns the PostgreSQL version or nil if another DBMS is used
	28	def postgresql_version
	29	postgresql? ? ActiveRecord::Base.connection.send(:postgresql_version) : nil
	30	end
	31
	32	# Returns true if the database is a PostgreSQL >=9.0 database with the unaccent extension installed
	33	def postgresql_unaccent?
	34	if postgresql?
	35	return @postgresql_unaccent unless @postgresql_unaccent.nil?
	36	begin
	37	sql = "SELECT name FROM pg_available_extensions WHERE installed_version IS NOT NULL and name = 'unaccent'"
	38	@postgresql_unaccent = postgresql_version >= 90000 && ActiveRecord::Base.connection.select_value(sql).present?
	39	rescue
	40	false
	41	end
	42	else
	43	false
	44	end
	45	end
	46
	47	# Resets database information
	48	def reset
	49	@postgresql_unaccent = nil
	50	end
	51	end
	52	end
	53	end

lib/plugins/acts_as_searchable/lib/acts_as_searchable.rb +6 -3

             # Redmine - project management software
             # Copyright (C) 2006-2015  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module Redmine
               module Acts
                 module Searchable
                   def self.included(base)
                     base.extend ClassMethods
                   end
                   module ClassMethods
                     # Adds the search methods to the class.
                     #
                     # Options:
                     # * :columns - a column or an array of columns to search
                     # * :project_key - project foreign key (default to project_id)
                     # * :date_column - name of the datetime column used to sort results (default to :created_on)
                     # * :permission - permission required to search the model
                     # * :scope - scope used to search results
                     # * :preload - associations to preload when loading results for display
                     def acts_as_searchable(options = {})
                       return if self.included_modules.include?(Redmine::Acts::Searchable::InstanceMethods)
                       options.assert_valid_keys(:columns, :project_key, :date_column, :permission, :scope, :preload)
                       cattr_accessor :searchable_options
                       self.searchable_options = options
                       if searchable_options[:columns].nil?
                         raise 'No searchable column defined.'
                       elsif !searchable_options[:columns].is_a?(Array)
                         searchable_options[:columns] = [] << searchable_options[:columns]
                       end
                       searchable_options[:project_key] ||= "#{table_name}.project_id"
                       searchable_options[:date_column] ||= :created_on
                       # Should we search additional associations on this model ?
                       searchable_options[:search_custom_fields] = reflect_on_association(:custom_values).present?
                       searchable_options[:search_attachments] = reflect_on_association(:attachments).present?
                       searchable_options[:search_journals] = reflect_on_association(:journals).present?
                       send :include, Redmine::Acts::Searchable::InstanceMethods
                     end
                   end
                   module InstanceMethods
                     def self.included(base)
                       base.extend ClassMethods
                     end
                     module ClassMethods
                       # Searches the model for the given tokens and user visibility.
                       # The projects argument can be either nil (will search all projects), a project or an array of projects.
                       # Returns an array that contains the rank and id of all results.
                       # In current implementation, the rank is the record timestamp converted as an integer.
                       #
                       # Valid options:
                       # * :titles_only - searches tokens in the first searchable column only
                       # * :all_words - searches results that match all token
                       # * :
                       # * :limit - maximum number of results to return
                       #
                       # Example:
                       #   Issue.search_result_ranks_and_ids("foo")
                       #   # => [[1419595329, 69], [1419595622, 123]]
                       def search_result_ranks_and_ids(tokens, user=User.current, projects=nil, options={})
                         tokens = [] << tokens unless tokens.is_a?(Array)
                         projects = [] << projects if projects.is_a?(Project)
                         columns = searchable_options[:columns]
                         columns = columns[0..0] if options[:titles_only]
                         r = []
                         queries = 0
                         unless options[:attachments] == 'only'
                           r = fetch_ranks_and_ids(
                             search_scope(user, projects, options).
                             where(search_tokens_condition(columns, tokens, options[:all_words])),
                             options[:limit]
                           )
                           queries += 1
                           if !options[:titles_only] && searchable_options[:search_custom_fields]
                             searchable_custom_fields = CustomField.where(:type => "#{self.name}CustomField", :searchable => true).to_a
                             if searchable_custom_fields.any?
                               fields_by_visibility = searchable_custom_fields.group_by {|field|
                                 field.visibility_by_project_condition(searchable_options[:project_key], user, "#{CustomValue.table_name}.custom_field_id")
                               }
                               clauses = []
                               fields_by_visibility.each do |visibility, fields|
                                 clauses << "(#{CustomValue.table_name}.custom_field_id IN (#{fields.map(&:id).join(',')}) AND (#{visibility}))"
                               end
                               visibility = clauses.join(' OR ')
                               r |= fetch_ranks_and_ids(
                                 search_scope(user, projects, options).
                                 joins(:custom_values).
                                 where(visibility).
                                 where(search_tokens_condition(["#{CustomValue.table_name}.value"], tokens, options[:all_words])),
                                 options[:limit]
                               )
                               queries += 1
                             end
                           end
                           if !options[:titles_only] && searchable_options[:search_journals]
                             r |= fetch_ranks_and_ids(
                               search_scope(user, projects, options).
                               joins(:journals).
                               where("#{Journal.table_name}.private_notes = ? OR (#{Project.allowed_to_condition(user, :view_private_notes)})", false).
                               where(search_tokens_condition(["#{Journal.table_name}.notes"], tokens, options[:all_words])),
                               options[:limit]
                             )
                             queries += 1
                           end
                         end
                         if searchable_options[:search_attachments] && (options[:titles_only] ? options[:attachments] == 'only' : options[:attachments] != '0')
                           r |= fetch_ranks_and_ids(
                             search_scope(user, projects, options).
                             joins(:attachments).
                             where(search_tokens_condition(["#{Attachment.table_name}.filename", "#{Attachment.table_name}.description"], tokens, options[:all_words])),
                             options[:limit]
                           )
                           queries += 1
                         end
                         if queries > 1
                           r = r.sort.reverse
                           if options[:limit] && r.size > options[:limit]
                             r = r[0, options[:limit]]
                           end
                         end
                         r
                       end
                       def search_tokens_condition(columns, tokens, all_words)
                         token_clauses = columns.map {|column| "(#{search_token_match_statement(column)})"}
                         sql = (['(' + token_clauses.join(' OR ') + ')'] * tokens.size).join(all_words ? ' AND ' : ' OR ')
                         [sql, * (tokens.collect {|w| "%#{w}%"} * token_clauses.size).sort]
                       end
                       private :search_tokens_condition
                       def search_token_match_statement(column, value='?')
-                        case connection.adapter_name
+                        if Redmine::Database.postgresql?
-                        when /postgresql/i
+                          if Redmine::Database.postgresql_unaccent?
-                          "#{column} ILIKE #{value}"
+                            "unaccent(#{column}) ILIKE unaccent(#{value})"
+                          else
+                            "#{column} ILIKE #{value}"
+                          end
                         else
                           "#{column} LIKE #{value}"
                         end
                       end
                       private :search_token_match_statement
                       def fetch_ranks_and_ids(scope, limit)
                         scope.
                           reorder(searchable_options[:date_column] => :desc, :id => :desc).
                           limit(limit).
                           uniq.
                           pluck(searchable_options[:date_column], :id).
                           # converts timestamps to integers for faster sort
                           map {|timestamp, id| [timestamp.to_i, id]}
                       end
                       private :fetch_ranks_and_ids
                       # Returns the search scope for user and projects
                       def search_scope(user, projects, options={})
                         if projects.is_a?(Array) && projects.empty?
                           # no results
                           return none
                         end
                         scope = (searchable_options[:scope] || self)
                         if scope.is_a? Proc
                           scope = scope.call(options)
                         end
                         if respond_to?(:visible) && !searchable_options.has_key?(:permission)
                           scope = scope.visible(user)
                         else
                           permission = searchable_options[:permission] || :view_project
                           scope = scope.where(Project.allowed_to_condition(user, permission))
                         end
                         if projects
                           scope = scope.where("#{searchable_options[:project_key]} IN (?)", projects.map(&:id))
                         end
                         scope
                       end
                       private :search_scope
                       # Returns search results of given ids
                       def search_results_from_ids(ids)
                         where(:id => ids).preload(searchable_options[:preload]).to_a
                       end
                       # Returns search results with same arguments as search_result_ranks_and_ids
                       def search_results(*args)
                         ranks_and_ids = search_result_ranks_and_ids(*args)
                         search_results_from_ids(ranks_and_ids.map(&:last))
                       end
                     end
                   end
                 end
               end
             end

test/test_helper.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2015  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             if ENV["COVERAGE"]
               require 'simplecov'
               require File.expand_path(File.dirname(__FILE__) + "/coverage/html_formatter")
               SimpleCov.formatter = Redmine::Coverage::HtmlFormatter
               SimpleCov.start 'rails'
             end
             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 'net/ldap'
             require 'mocha/setup'
             class ActionView::TestCase
               helper :application
               include ApplicationHelper
             end
             class ActiveSupport::TestCase
               include ActionDispatch::TestProcess
               self.use_transactional_fixtures = true
               self.use_instantiated_fixtures  = false
               def uploaded_test_file(name, mime)
                 fixture_file_upload("files/#{name}", mime, true)
               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 with_locale(locale, &block)
                 saved_localed = ::I18n.locale
                 ::I18n.locale = locale
                 yield
               ensure
                 ::I18n.locale = saved_localed
               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
               def convert_installed?
                 self.class.convert_installed?
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 path = Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
                 # Unlike ruby, JRuby returns Rails.root with backslashes under Windows
                 path.tr("\\", "/")
               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 sqlite?
                 ActiveRecord::Base.connection.adapter_name =~ /sqlite/i
               end
               def mysql?
                 ActiveRecord::Base.connection.adapter_name =~ /mysql/i
               end
+              def postgresql?
+                ActiveRecord::Base.connection.adapter_name =~ /postgresql/i
+              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_select_error(arg)
                 assert_select '#errorExplanation', :text => arg
               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 = Nokogiri::HTML(CGI::unescapeHTML(String.new(text))).root
                 assert_select(d, *args, &block)
               end
               def assert_select_email(*args, &block)
                 email = ActionMailer::Base.deliveries.last
                 assert_not_nil email
                 html_body = email.parts.detect {|part| part.content_type.include?('text/html')}.try(&:body)
                 assert_not_nil html_body
                 assert_select_in html_body.encoded, *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
               # Returns the lft value for a new root issue
               def new_issue_lft
               end
             end
             module Redmine
               class RoutingTest < ActionDispatch::IntegrationTest
                 def should_route(arg)
                   arg = arg.dup
                   request = arg.keys.detect {|key| key.is_a?(String)}
                   raise ArgumentError unless request
                   options = arg.slice!(request)
                   raise ArgumentError unless request =~ /\A(GET|POST|PUT|PATCH|DELETE)\s+(.+)\z/
                   method, path = $1.downcase.to_sym, $2
                   raise ArgumentError unless arg.values.first =~ /\A(.+)#(.+)\z/
                   controller, action = $1, $2
                   assert_routing(
                     {:method => method, :path => path},
                     options.merge(:controller => controller, :action => action)
                   )
                 end
               end
               class IntegrationTest < ActionDispatch::IntegrationTest
                 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 credentials(user, password=nil)
                   {'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
                 end
               end
               module ApiTest
                 API_FORMATS = %w(json xml).freeze
                 # Base class for API tests
                 class Base < Redmine::IntegrationTest
                   def setup
                     Setting.rest_api_enabled = '1'
                   end
                   def teardown
                     Setting.rest_api_enabled = '0'
                   end
                   # Uploads content using the XML API and returns the attachment token
                   def xml_upload(content, credentials)
                     upload('xml', content, credentials)
                   end
                   # Uploads content using the JSON API and returns the attachment token
                   def json_upload(content, credentials)
                     upload('json', content, credentials)
                   end
                   def upload(format, content, credentials)
                     set_tmp_attachments_directory
                     assert_difference 'Attachment.count' do
                       post "/uploads.#{format}", content, {"CONTENT_TYPE" => 'application/octet-stream'}.merge(credentials)
                       assert_response :created
                     end
                     data = response_data
                     assert_kind_of Hash, data['upload']
                     token = data['upload']['token']
                     assert_not_nil token
                     token
                   end
                   # Parses the response body based on its content type
                   def response_data
                     unless response.content_type.to_s =~ /^application\/(.+)/
                       raise "Unexpected response type: #{response.content_type}"
                     end
                     format = $1
                     case format
                     when 'xml'
                       Hash.from_xml(response.body)
                     when 'json'
                       ActiveSupport::JSON.decode(response.body)
                     else
                       raise "Unknown response format: #{format}"
                     end
                   end
                 end
                 class Routing < Redmine::RoutingTest
                   def should_route(arg)
                     arg = arg.dup
                     request = arg.keys.detect {|key| key.is_a?(String)}
                     raise ArgumentError unless request
                     options = arg.slice!(request)
                     API_FORMATS.each do |format|
                       format_request = request.sub /$/, ".#{format}"
                       super options.merge(format_request => arg[request], :format => format)
                     end
                   end
                 end
               end
             end

test/unit/search_test.rb +19 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2015  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class SearchTest < ActiveSupport::TestCase
               fixtures :users,
                        :members,
                        :member_roles,
                        :projects,
                        :projects_trackers,
                        :roles,
                        :enabled_modules,
                        :issues,
                        :trackers,
                        :issue_statuses,
                        :enumerations,
                        :journals,
                        :journal_details,
                        :repositories,
                        :changesets
               def setup
                 @project = Project.find(1)
                 @issue_keyword = '%unable to print recipes%'
                 @issue = Issue.find(1)
                 @changeset_keyword = '%very first commit%'
                 @changeset = Changeset.find(100)
               end
               def test_search_by_anonymous
                 User.current = nil
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert r.include?(@changeset)
                 # Removes the :view_changesets permission from Anonymous role
                 remove_permission Role.anonymous, :view_changesets
                 User.current = nil
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
                 # Make the project private
                 @project.update_attribute :is_public, false
                 r = Issue.search_results(@issue_keyword)
                 assert !r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
               end
               def test_search_by_user
                 User.current = User.find_by_login('rhill')
                 assert User.current.memberships.empty?
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert r.include?(@changeset)
                 # Removes the :view_changesets permission from Non member role
                 remove_permission Role.non_member, :view_changesets
                 User.current = User.find_by_login('rhill')
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
                 # Make the project private
                 @project.update_attribute :is_public, false
                 r = Issue.search_results(@issue_keyword)
                 assert !r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
               end
               def test_search_by_allowed_member
                 User.current = User.find_by_login('jsmith')
                 assert User.current.projects.include?(@project)
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert r.include?(@changeset)
                 # Make the project private
                 @project.update_attribute :is_public, false
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert r.include?(@changeset)
               end
               def test_search_by_unallowed_member
                 # Removes the :view_changesets permission from user's and non member role
                 remove_permission Role.find(1), :view_changesets
                 remove_permission Role.non_member, :view_changesets
                 User.current = User.find_by_login('jsmith')
                 assert User.current.projects.include?(@project)
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
                 # Make the project private
                 @project.update_attribute :is_public, false
                 r = Issue.search_results(@issue_keyword)
                 assert r.include?(@issue)
                 r = Changeset.search_results(@changeset_keyword)
                 assert !r.include?(@changeset)
               end
               def test_search_issue_with_multiple_hits_in_journals
                 issue = Issue.find(1)
                 assert_equal 2, issue.journals.where("notes LIKE '%notes%'").count
                 r = Issue.search_results('%notes%')
                 assert_equal 1, r.size
                 assert_equal issue, r.first
               end
               def test_search_should_be_case_insensitive
                 issue = Issue.generate!(:subject => "AzerTY")
                 r = Issue.search_results('AZERty')
                 assert_include issue, r
               end
               def test_search_should_be_case_insensitive_with_accented_characters
                 unless sqlite?
                   issue1 = Issue.generate!(:subject => "Special chars: ÖÖ")
                   issue2 = Issue.generate!(:subject => "Special chars: Öö")
                   r = Issue.search_results('ÖÖ')
                   assert_include issue1, r
                   assert_include issue2, r
                 end
               end
               def test_search_should_be_case_and_accent_insensitive_with_mysql
                 if mysql?
                   issue1 = Issue.generate!(:subject => "OO")
                   issue2 = Issue.generate!(:subject => "oo")
                   r = Issue.search_results('ÖÖ')
                   assert_include issue1, r
                   assert_include issue2, r
                 end
               end
+              def test_search_should_be_case_and_accent_insensitive_with_postgresql_and_noaccent_extension
+                if postgresql?
+                  skip unless Redmine::Database.postgresql_version >= 90000
+                  # Extension will be rollbacked with the test transaction
+                  ActiveRecord::Base.connection.execute("CREATE EXTENSION IF NOT EXISTS unaccent")
+                  Redmine::Database.reset
+                  assert Redmine::Database.postgresql_unaccent?
+                  issue1 = Issue.generate!(:subject => "OO")
+                  issue2 = Issue.generate!(:subject => "oo")
+                  r = Issue.search_results('ÖÖ')
+                  assert_include issue1, r
+                  assert_include issue2, r
+                end
+              ensure
+                Redmine::Database.reset
+              end
               private
               def remove_permission(role, permission)
                 role.permissions = role.permissions - [ permission ]
                 role.save
               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