comparison test/unit/query_test.rb @ 1115:433d4f72a19b redmine-2.2

Update to Redmine SVN revision 11137 on 2.2-stable branch

 # Redmine - project management software
-# Copyright (C) 2006-2011  Jean-Philippe Lang
+# Copyright (C) 2006-2012  Jean-Philippe Lang
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; either version 2
 # of the License, or (at your option) any later version.

 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 require File.expand_path('../../test_helper', __FILE__)
 
 class QueryTest < ActiveSupport::TestCase
+  include Redmine::I18n
+
   fixtures :projects, :enabled_modules, :users, :members,
            :member_roles, :roles, :trackers, :issue_statuses,
            :issue_categories, :enumerations, :issues,
            :watchers, :custom_fields, :custom_values, :versions,
            :queries,
-           :projects_trackers
+           :projects_trackers,
+           :custom_fields_trackers
 
   def test_custom_fields_for_all_projects_should_be_available_in_global_queries
     query = Query.new(:project => nil, :name => '_')
     assert query.available_filters.has_key?('cf_1')
     assert !query.available_filters.has_key?('cf_3')

     assert project_ids.include?("1")  #public project
     assert !project_ids.include?("2") #private project user cannot see
   end
 
   def find_issues_with_query(query)
-    Issue.find :all,
-      :include => [ :assigned_to, :status, :tracker, :project, :priority ],
-      :conditions => query.statement
+    Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
+         query.statement
+       ).all
   end
 
   def assert_find_issues_with_query_is_successful(query)
     assert_nothing_raised do
       find_issues_with_query(query)

     issues = find_issues_with_query(query)
     assert !issues.empty?
     assert issues.all? {|i| i.start_date.nil?}
   end
 
+  def test_operator_none_for_string_custom_field
+    query = Query.new(:project => Project.find(1), :name => '_')
+    query.add_filter('cf_2', '!*', [''])
+    assert query.has_filter?('cf_2')
+    issues = find_issues_with_query(query)
+    assert !issues.empty?
+    assert issues.all? {|i| i.custom_field_value(2).blank?}
+  end
+
   def test_operator_all
     query = Query.new(:project => Project.find(1), :name => '_')
     query.add_filter('fixed_version_id', '*', [''])
     query.add_filter('cf_1', '*', [''])
     assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")

     issues = find_issues_with_query(query)
     assert !issues.empty?
     assert issues.all? {|i| i.start_date.present?}
   end
 
+  def test_operator_all_for_string_custom_field
+    query = Query.new(:project => Project.find(1), :name => '_')
+    query.add_filter('cf_2', '*', [''])
+    assert query.has_filter?('cf_2')
+    issues = find_issues_with_query(query)
+    assert !issues.empty?
+    assert issues.all? {|i| i.custom_field_value(2).present?}
+  end
+
   def test_numeric_filter_should_not_accept_non_numeric_values
     query = Query.new(:name => '_')
     query.add_filter('estimated_hours', '=', ['a'])
 
     assert query.has_filter?('estimated_hours')

     issues = find_issues_with_query(query)
     assert_equal 1, issues.size
     assert_equal 2, issues.first.id
   end
 
+  def test_operator_is_on_integer_custom_field
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['12'])
+    issues = find_issues_with_query(query)
+    assert_equal 1, issues.size
+    assert_equal 2, issues.first.id
+  end
+
+  def test_operator_is_on_integer_custom_field_should_accept_negative_value
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['-12'])
+    assert query.valid?
+    issues = find_issues_with_query(query)
+    assert_equal 1, issues.size
+    assert_equal 2, issues.first.id
+  end
+
+  def test_operator_is_on_float_custom_field
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['12.7'])
+    issues = find_issues_with_query(query)
+    assert_equal 1, issues.size
+    assert_equal 2, issues.first.id
+  end
+
+  def test_operator_is_on_float_custom_field_should_accept_negative_value
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['-12.7'])
+    assert query.valid?
+    issues = find_issues_with_query(query)
+    assert_equal 1, issues.size
+    assert_equal 2, issues.first.id
+  end
+
+  def test_operator_is_on_multi_list_custom_field
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
+      :possible_values => ['value1', 'value2', 'value3'], :multiple => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['value1'])
+    issues = find_issues_with_query(query)
+    assert_equal [1, 3], issues.map(&:id).sort
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '=', ['value2'])
+    issues = find_issues_with_query(query)
+    assert_equal [1], issues.map(&:id).sort
+  end
+
+  def test_operator_is_not_on_multi_list_custom_field
+    f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
+      :possible_values => ['value1', 'value2', 'value3'], :multiple => true)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '!', ['value1'])
+    issues = find_issues_with_query(query)
+    assert !issues.map(&:id).include?(1)
+    assert !issues.map(&:id).include?(3)
+
+    query = Query.new(:name => '_')
+    query.add_filter("cf_#{f.id}", '!', ['value2'])
+    issues = find_issues_with_query(query)
+    assert !issues.map(&:id).include?(1)
+    assert issues.map(&:id).include?(3)
+  end
+
+  def test_operator_is_on_is_private_field
+    # is_private filter only available for those who can set issues private
+    User.current = User.find(2)
+
+    query = Query.new(:name => '_')
+    assert query.available_filters.key?('is_private')
+
+    query.add_filter("is_private", '=', ['1'])
+    issues = find_issues_with_query(query)
+    assert issues.any?
+    assert_nil issues.detect {|issue| !issue.is_private?}
+  ensure
+    User.current = nil
+  end
+
+  def test_operator_is_not_on_is_private_field
+    # is_private filter only available for those who can set issues private
+    User.current = User.find(2)
+
+    query = Query.new(:name => '_')
+    assert query.available_filters.key?('is_private')
+
+    query.add_filter("is_private", '!', ['1'])
+    issues = find_issues_with_query(query)
+    assert issues.any?
+    assert_nil issues.detect {|issue| issue.is_private?}
+  ensure
+    User.current = nil
+  end
+
   def test_operator_greater_than
     query = Query.new(:project => Project.find(1), :name => '_')
     query.add_filter('done_ratio', '>=', ['40'])
     assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")
     find_issues_with_query(query)

     query.add_filter('estimated_hours', '>=', ['40.5'])
     assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")
     find_issues_with_query(query)
   end
 
-  def test_operator_greater_than_on_custom_field
+  def test_operator_greater_than_on_int_custom_field
     f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
-    query = Query.new(:project => Project.find(1), :name => '_')
-    query.add_filter("cf_#{f.id}", '>=', ['40'])
-    assert query.statement.include?("CAST(custom_values.value AS decimal(60,3)) >= 40.0")
-    find_issues_with_query(query)
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
+    CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
+
+    query = Query.new(:project => Project.find(1), :name => '_')
+    query.add_filter("cf_#{f.id}", '>=', ['8'])
+    issues = find_issues_with_query(query)
+    assert_equal 1, issues.size
+    assert_equal 2, issues.first.id
   end
 
   def test_operator_lesser_than
     query = Query.new(:project => Project.find(1), :name => '_')
     query.add_filter('done_ratio', '<=', ['30'])

   def test_operator_in_less_than
     query = Query.new(:project => Project.find(1), :name => '_')
     query.add_filter('due_date', '<t+', ['15'])
     issues = find_issues_with_query(query)
     assert !issues.empty?
+    issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}
+  end
+
+  def test_operator_in_the_next_days
+    query = Query.new(:project => Project.find(1), :name => '_')
+    query.add_filter('due_date', '><t+', ['15'])
+    issues = find_issues_with_query(query)
+    assert !issues.empty?
     issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
   end
 
   def test_operator_less_than_ago
     Issue.find(7).update_attribute(:due_date, (Date.today - 3))
     query = Query.new(:project => Project.find(1), :name => '_')
     query.add_filter('due_date', '>t-', ['3'])
+    issues = find_issues_with_query(query)
+    assert !issues.empty?
+    issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}
+  end
+
+  def test_operator_in_the_past_days
+    Issue.find(7).update_attribute(:due_date, (Date.today - 3))
+    query = Query.new(:project => Project.find(1), :name => '_')
+    query.add_filter('due_date', '><t-', ['3'])
     issues = find_issues_with_query(query)
     assert !issues.empty?
     issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
   end
 

     assert result.include?(i1)
     assert result.include?(i2)
     assert !result.include?(i3)
   end
 
+  def test_user_custom_field_filtered_on_me
+    User.current = User.find(2)
+    cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])
+    issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)
+    issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})
+
+    query = Query.new(:name => '_', :project => Project.find(1))
+    filter = query.available_filters["cf_#{cf.id}"]
+    assert_not_nil filter
+    assert_include 'me', filter[:values].map{|v| v[1]}
+
+    query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}
+    result = query.issues
+    assert_equal 1, result.size
+    assert_equal issue1, result.first
+  end
+
+  def test_filter_my_projects
+    User.current = User.find(2)
+    query = Query.new(:name => '_')
+    filter = query.available_filters['project_id']
+    assert_not_nil filter
+    assert_include 'mine', filter[:values].map{|v| v[1]}
+
+    query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}
+    result = query.issues
+    assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}
+  end
+
   def test_filter_watched_issues
     User.current = User.find(1)
     query = Query.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
     result = find_issues_with_query(query)
     assert_not_nil result

     assert !result.empty?
     assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)
     User.current = nil
   end
 
+  def test_filter_on_project_custom_field
+    field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
+    CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo')
+    CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo')
+
+    query = Query.new(:name => '_')
+    filter_name = "project.cf_#{field.id}"
+    assert_include filter_name, query.available_filters.keys
+    query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
+    assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort
+  end
+
+  def test_filter_on_author_custom_field
+    field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
+    CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
+
+    query = Query.new(:name => '_')
+    filter_name = "author.cf_#{field.id}"
+    assert_include filter_name, query.available_filters.keys
+    query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
+    assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort
+  end
+
+  def test_filter_on_assigned_to_custom_field
+    field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
+    CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
+
+    query = Query.new(:name => '_')
+    filter_name = "assigned_to.cf_#{field.id}"
+    assert_include filter_name, query.available_filters.keys
+    query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
+    assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort
+  end
+
+  def test_filter_on_fixed_version_custom_field
+    field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
+    CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo')
+
+    query = Query.new(:name => '_')
+    filter_name = "fixed_version.cf_#{field.id}"
+    assert_include filter_name, query.available_filters.keys
+    query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
+    assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort
+  end
+
+  def test_filter_on_relations_with_a_specific_issue
+    IssueRelation.delete_all
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=', :values => ['1']}}
+    assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=', :values => ['2']}}
+    assert_equal [1], find_issues_with_query(query).map(&:id).sort
+  end
+
+  def test_filter_on_relations_with_any_issues_in_a_project
+    IssueRelation.delete_all
+    with_settings :cross_project_issue_relations => '1' do
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
+    end
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=p', :values => ['2']}}
+    assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=p', :values => ['3']}}
+    assert_equal [1], find_issues_with_query(query).map(&:id).sort
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=p', :values => ['4']}}
+    assert_equal [], find_issues_with_query(query).map(&:id).sort
+  end
+
+  def test_filter_on_relations_with_any_issues_not_in_a_project
+    IssueRelation.delete_all
+    with_settings :cross_project_issue_relations => '1' do
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
+      #IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
+    end
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}
+    assert_equal [1], find_issues_with_query(query).map(&:id).sort
+  end
+
+  def test_filter_on_relations_with_no_issues_in_a_project
+    IssueRelation.delete_all
+    with_settings :cross_project_issue_relations => '1' do
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
+      IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first)
+      IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3))
+    end
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '!p', :values => ['2']}}
+    ids = find_issues_with_query(query).map(&:id).sort
+    assert_include 2, ids
+    assert_not_include 1, ids
+    assert_not_include 3, ids
+  end
+
+  def test_filter_on_relations_with_no_issues
+    IssueRelation.delete_all
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '!*', :values => ['']}}
+    ids = find_issues_with_query(query).map(&:id)
+    assert_equal [], ids & [1, 2, 3]
+    assert_include 4, ids
+  end
+
+  def test_filter_on_relations_with_any_issues
+    IssueRelation.delete_all
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
+    IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
+
+    query = Query.new(:name => '_')
+    query.filters = {"relates" => {:operator => '*', :values => ['']}}
+    assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort
+  end
+
   def test_statement_should_be_nil_with_no_filters
     q = Query.new(:name => '_')
     q.filters = {}
 
     assert q.valid?
     assert_nil q.statement
   end
 
   def test_default_columns
     q = Query.new
-    assert !q.columns.empty?
+    assert q.columns.any?
+    assert q.inline_columns.any?
+    assert q.block_columns.empty?
   end
 
   def test_set_column_names
     q = Query.new
     q.column_names = ['tracker', :subject, '', 'unknonw_column']
     assert_equal [:tracker, :subject], q.columns.collect {|c| c.name}
     c = q.columns.first
     assert q.has_column?(c)
   end
 
+  def test_inline_and_block_columns
+    q = Query.new
+    q.column_names = ['subject', 'description', 'tracker']
+
+    assert_equal [:subject, :tracker], q.inline_columns.map(&:name)
+    assert_equal [:description], q.block_columns.map(&:name)
+  end
+
+  def test_custom_field_columns_should_be_inline
+    q = Query.new
+    columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}
+    assert columns.any?
+    assert_nil columns.detect {|column| !column.inline?}
+  end
+
+  def test_query_should_preload_spent_hours
+    q = Query.new(:name => '_', :column_names => [:subject, :spent_hours])
+    assert q.has_column?(:spent_hours)
+    issues = q.issues
+    assert_not_nil issues.first.instance_variable_get("@spent_hours")
+  end
+
   def test_groupable_columns_should_include_custom_fields
     q = Query.new
-    assert q.groupable_columns.detect {|c| c.is_a? QueryCustomFieldColumn}
+    column = q.groupable_columns.detect {|c| c.name == :cf_1}
+    assert_not_nil column
+    assert_kind_of QueryCustomFieldColumn, column
+  end
+
+  def test_groupable_columns_should_not_include_multi_custom_fields
+    field = CustomField.find(1)
+    field.update_attribute :multiple, true
+
+    q = Query.new
+    column = q.groupable_columns.detect {|c| c.name == :cf_1}
+    assert_nil column
+  end
+
+  def test_groupable_columns_should_include_user_custom_fields
+    cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user')
+
+    q = Query.new
+    assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
+  end
+
+  def test_groupable_columns_should_include_version_custom_fields
+    cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version')
+
+    q = Query.new
+    assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
   end
 
   def test_grouped_with_valid_column
     q = Query.new(:group_by => 'status')
     assert q.grouped?

       assert q.sortable_columns.has_key?('author')
       assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author']
     end
   end
 
+  def test_sortable_columns_should_include_custom_field
+    q = Query.new
+    assert q.sortable_columns['cf_1']
+  end
+
+  def test_sortable_columns_should_not_include_multi_custom_field
+    field = CustomField.find(1)
+    field.update_attribute :multiple, true
+
+    q = Query.new
+    assert !q.sortable_columns['cf_1']
+  end
+
   def test_default_sort
     q = Query.new
     assert_equal [], q.sort_criteria
   end
 

   def test_sort_by_string_custom_field_asc
     q = Query.new
     c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
     assert c
     assert c.sortable
-    issues = Issue.find :all,
-                        :include => [ :assigned_to, :status, :tracker, :project, :priority ],
-                        :conditions => q.statement,
-                        :order => "#{c.sortable} ASC"
+    issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
+         q.statement
+       ).order("#{c.sortable} ASC").all
     values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
     assert !values.empty?
     assert_equal values.sort, values
   end
 
   def test_sort_by_string_custom_field_desc
     q = Query.new
     c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
     assert c
     assert c.sortable
-    issues = Issue.find :all,
-                        :include => [ :assigned_to, :status, :tracker, :project, :priority ],
-                        :conditions => q.statement,
-                        :order => "#{c.sortable} DESC"
+    issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
+         q.statement
+       ).order("#{c.sortable} DESC").all
     values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
     assert !values.empty?
     assert_equal values.sort.reverse, values
   end
 
   def test_sort_by_float_custom_field_asc
     q = Query.new
     c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }
     assert c
     assert c.sortable
-    issues = Issue.find :all,
-                        :include => [ :assigned_to, :status, :tracker, :project, :priority ],
-                        :conditions => q.statement,
-                        :order => "#{c.sortable} ASC"
+    issues = Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where(
+         q.statement
+       ).order("#{c.sortable} ASC").all
     values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact
     assert !values.empty?
     assert_equal values.sort, values
   end
 

     issue_count = q.issue_count
     assert_equal q.issues.size, issue_count
   end
 
   def test_issue_count_with_archived_issues
-    p = Project.generate!( :status => Project::STATUS_ARCHIVED )
+    p = Project.generate! do |project|
+      project.status = Project::STATUS_ARCHIVED
+    end
     i = Issue.generate!( :project => p, :tracker => p.trackers.first )
     assert !i.visible?
 
     test_issue_count
   end

     assert_kind_of Hash, count_by_group
     assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
     assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
   end
 
+  def test_issue_count_with_nil_group_only
+    Issue.update_all("assigned_to_id = NULL")
+
+    q = Query.new(:name => '_', :group_by => 'assigned_to')
+    count_by_group = q.issue_count_by_group
+    assert_kind_of Hash, count_by_group
+    assert_equal 1, count_by_group.keys.size
+    assert_nil count_by_group.keys.first
+  end
+
+  def test_issue_ids
+    q = Query.new(:name => '_')
+    order = "issues.subject, issues.id"
+    issues = q.issues(:order => order)
+    assert_equal issues.map(&:id), q.issue_ids(:order => order)
+  end
+
   def test_label_for
-    q = Query.new
-    assert_equal 'assigned_to', q.label_for('assigned_to_id')
+    set_language_if_valid 'en'
+    q = Query.new
+    assert_equal 'Assignee', q.label_for('assigned_to_id')
+  end
+
+  def test_label_for_fr
+    set_language_if_valid 'fr'
+    q = Query.new
+    s = "Assign\xc3\xa9 \xc3\xa0"
+    s.force_encoding('UTF-8') if s.respond_to?(:force_encoding)
+    assert_equal s, q.label_for('assigned_to_id')
   end
 
   def test_editable_by
     admin = User.find(1)
     manager = User.find(2)

 
     should "include users of visible projects in cross-project view" do
       users = @query.available_filters["assigned_to_id"]
       assert_not_nil users
       assert users[:values].map{|u|u[1]}.include?("3")
+    end
+
+    should "include users of subprojects" do
+      user1 = User.generate!
+      user2 = User.generate!
+      project = Project.find(1)
+      Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])
+      @query.project = project
+
+      users = @query.available_filters["assigned_to_id"]
+      assert_not_nil users
+      assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)
+      assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)
     end
 
     should "include visible projects in cross-project view" do
       projects = @query.available_filters["project_id"]
       assert_not_nil projects

         @guest = User.generate!
         User.add_to_project(@manager, @project, @manager_role)
         User.add_to_project(@developer, @project, @developer_role)
         User.add_to_project(@boss, @project, [@manager_role, @developer_role])
         
-        @issue1 = Issue.generate_for_project!(@project, :assigned_to_id => @manager.id)
-        @issue2 = Issue.generate_for_project!(@project, :assigned_to_id => @developer.id)
-        @issue3 = Issue.generate_for_project!(@project, :assigned_to_id => @boss.id)
-        @issue4 = Issue.generate_for_project!(@project, :assigned_to_id => @guest.id)
-        @issue5 = Issue.generate_for_project!(@project)
+        @issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)
+        @issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)
+        @issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)
+        @issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)
+        @issue5 = Issue.generate!(:project => @project)
       end
 
       should "search assigned to for users with the Role" do
         @query = Query.new(:name => '_', :project => @project)
         @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])