To check out this repository please hg clone the following URL, or open the URL using EasyMercurial or your preferred Mercurial client.
root / .svn / pristine / 45 / 4589164e770ce01b12657f2cebf30982504c9054.svn-base @ 1298:4f746d8966dd
History | View | Annotate | Download (49.1 KB)
| 1 | 1295:622f24f53b42 | Chris | # Redmine - project management software |
|---|---|---|---|
| 2 | # Copyright (C) 2006-2013 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 | require File.expand_path('../../test_helper', __FILE__)
|
||
| 19 | |||
| 20 | class QueryTest < ActiveSupport::TestCase |
||
| 21 | include Redmine::I18n |
||
| 22 | |||
| 23 | fixtures :projects, :enabled_modules, :users, :members, |
||
| 24 | :member_roles, :roles, :trackers, :issue_statuses, |
||
| 25 | :issue_categories, :enumerations, :issues, |
||
| 26 | :watchers, :custom_fields, :custom_values, :versions, |
||
| 27 | :queries, |
||
| 28 | :projects_trackers, |
||
| 29 | :custom_fields_trackers |
||
| 30 | |||
| 31 | def test_available_filters_should_be_ordered |
||
| 32 | query = IssueQuery.new |
||
| 33 | assert_equal 0, query.available_filters.keys.index('status_id')
|
||
| 34 | end |
||
| 35 | |||
| 36 | def test_custom_fields_for_all_projects_should_be_available_in_global_queries |
||
| 37 | query = IssueQuery.new(:project => nil, :name => '_') |
||
| 38 | assert query.available_filters.has_key?('cf_1')
|
||
| 39 | assert !query.available_filters.has_key?('cf_3')
|
||
| 40 | end |
||
| 41 | |||
| 42 | def test_system_shared_versions_should_be_available_in_global_queries |
||
| 43 | Version.find(2).update_attribute :sharing, 'system' |
||
| 44 | query = IssueQuery.new(:project => nil, :name => '_') |
||
| 45 | assert query.available_filters.has_key?('fixed_version_id')
|
||
| 46 | assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}
|
||
| 47 | end |
||
| 48 | |||
| 49 | def test_project_filter_in_global_queries |
||
| 50 | query = IssueQuery.new(:project => nil, :name => '_') |
||
| 51 | project_filter = query.available_filters["project_id"] |
||
| 52 | assert_not_nil project_filter |
||
| 53 | project_ids = project_filter[:values].map{|p| p[1]}
|
||
| 54 | assert project_ids.include?("1") #public project
|
||
| 55 | assert !project_ids.include?("2") #private project user cannot see
|
||
| 56 | end |
||
| 57 | |||
| 58 | def find_issues_with_query(query) |
||
| 59 | Issue.includes([:assigned_to, :status, :tracker, :project, :priority]).where( |
||
| 60 | query.statement |
||
| 61 | ).all |
||
| 62 | end |
||
| 63 | |||
| 64 | def assert_find_issues_with_query_is_successful(query) |
||
| 65 | assert_nothing_raised do |
||
| 66 | find_issues_with_query(query) |
||
| 67 | end |
||
| 68 | end |
||
| 69 | |||
| 70 | def assert_query_statement_includes(query, condition) |
||
| 71 | assert_include condition, query.statement |
||
| 72 | end |
||
| 73 | |||
| 74 | def assert_query_result(expected, query) |
||
| 75 | assert_nothing_raised do |
||
| 76 | assert_equal expected.map(&:id).sort, query.issues.map(&:id).sort |
||
| 77 | assert_equal expected.size, query.issue_count |
||
| 78 | end |
||
| 79 | end |
||
| 80 | |||
| 81 | def test_query_should_allow_shared_versions_for_a_project_query |
||
| 82 | subproject_version = Version.find(4) |
||
| 83 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 84 | query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])
|
||
| 85 | |||
| 86 | assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")
|
||
| 87 | end |
||
| 88 | |||
| 89 | def test_query_with_multiple_custom_fields |
||
| 90 | query = IssueQuery.find(1) |
||
| 91 | assert query.valid? |
||
| 92 | assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")
|
||
| 93 | issues = find_issues_with_query(query) |
||
| 94 | assert_equal 1, issues.length |
||
| 95 | assert_equal Issue.find(3), issues.first |
||
| 96 | end |
||
| 97 | |||
| 98 | def test_operator_none |
||
| 99 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 100 | query.add_filter('fixed_version_id', '!*', [''])
|
||
| 101 | query.add_filter('cf_1', '!*', [''])
|
||
| 102 | assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")
|
||
| 103 | assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")
|
||
| 104 | find_issues_with_query(query) |
||
| 105 | end |
||
| 106 | |||
| 107 | def test_operator_none_for_integer |
||
| 108 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 109 | query.add_filter('estimated_hours', '!*', [''])
|
||
| 110 | issues = find_issues_with_query(query) |
||
| 111 | assert !issues.empty? |
||
| 112 | assert issues.all? {|i| !i.estimated_hours}
|
||
| 113 | end |
||
| 114 | |||
| 115 | def test_operator_none_for_date |
||
| 116 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 117 | query.add_filter('start_date', '!*', [''])
|
||
| 118 | issues = find_issues_with_query(query) |
||
| 119 | assert !issues.empty? |
||
| 120 | assert issues.all? {|i| i.start_date.nil?}
|
||
| 121 | end |
||
| 122 | |||
| 123 | def test_operator_none_for_string_custom_field |
||
| 124 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 125 | query.add_filter('cf_2', '!*', [''])
|
||
| 126 | assert query.has_filter?('cf_2')
|
||
| 127 | issues = find_issues_with_query(query) |
||
| 128 | assert !issues.empty? |
||
| 129 | assert issues.all? {|i| i.custom_field_value(2).blank?}
|
||
| 130 | end |
||
| 131 | |||
| 132 | def test_operator_all |
||
| 133 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 134 | query.add_filter('fixed_version_id', '*', [''])
|
||
| 135 | query.add_filter('cf_1', '*', [''])
|
||
| 136 | assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")
|
||
| 137 | assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")
|
||
| 138 | find_issues_with_query(query) |
||
| 139 | end |
||
| 140 | |||
| 141 | def test_operator_all_for_date |
||
| 142 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 143 | query.add_filter('start_date', '*', [''])
|
||
| 144 | issues = find_issues_with_query(query) |
||
| 145 | assert !issues.empty? |
||
| 146 | assert issues.all? {|i| i.start_date.present?}
|
||
| 147 | end |
||
| 148 | |||
| 149 | def test_operator_all_for_string_custom_field |
||
| 150 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 151 | query.add_filter('cf_2', '*', [''])
|
||
| 152 | assert query.has_filter?('cf_2')
|
||
| 153 | issues = find_issues_with_query(query) |
||
| 154 | assert !issues.empty? |
||
| 155 | assert issues.all? {|i| i.custom_field_value(2).present?}
|
||
| 156 | end |
||
| 157 | |||
| 158 | def test_numeric_filter_should_not_accept_non_numeric_values |
||
| 159 | query = IssueQuery.new(:name => '_') |
||
| 160 | query.add_filter('estimated_hours', '=', ['a'])
|
||
| 161 | |||
| 162 | assert query.has_filter?('estimated_hours')
|
||
| 163 | assert !query.valid? |
||
| 164 | end |
||
| 165 | |||
| 166 | def test_operator_is_on_float |
||
| 167 | Issue.update_all("estimated_hours = 171.2", "id=2")
|
||
| 168 | |||
| 169 | query = IssueQuery.new(:name => '_') |
||
| 170 | query.add_filter('estimated_hours', '=', ['171.20'])
|
||
| 171 | issues = find_issues_with_query(query) |
||
| 172 | assert_equal 1, issues.size |
||
| 173 | assert_equal 2, issues.first.id |
||
| 174 | end |
||
| 175 | |||
| 176 | def test_operator_is_on_integer_custom_field |
||
| 177 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true) |
||
| 178 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7') |
||
| 179 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12') |
||
| 180 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 181 | |||
| 182 | query = IssueQuery.new(:name => '_') |
||
| 183 | query.add_filter("cf_#{f.id}", '=', ['12'])
|
||
| 184 | issues = find_issues_with_query(query) |
||
| 185 | assert_equal 1, issues.size |
||
| 186 | assert_equal 2, issues.first.id |
||
| 187 | end |
||
| 188 | |||
| 189 | def test_operator_is_on_integer_custom_field_should_accept_negative_value |
||
| 190 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true) |
||
| 191 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7') |
||
| 192 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12') |
||
| 193 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 194 | |||
| 195 | query = IssueQuery.new(:name => '_') |
||
| 196 | query.add_filter("cf_#{f.id}", '=', ['-12'])
|
||
| 197 | assert query.valid? |
||
| 198 | issues = find_issues_with_query(query) |
||
| 199 | assert_equal 1, issues.size |
||
| 200 | assert_equal 2, issues.first.id |
||
| 201 | end |
||
| 202 | |||
| 203 | def test_operator_is_on_float_custom_field |
||
| 204 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true) |
||
| 205 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3') |
||
| 206 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7') |
||
| 207 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 208 | |||
| 209 | query = IssueQuery.new(:name => '_') |
||
| 210 | query.add_filter("cf_#{f.id}", '=', ['12.7'])
|
||
| 211 | issues = find_issues_with_query(query) |
||
| 212 | assert_equal 1, issues.size |
||
| 213 | assert_equal 2, issues.first.id |
||
| 214 | end |
||
| 215 | |||
| 216 | def test_operator_is_on_float_custom_field_should_accept_negative_value |
||
| 217 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true) |
||
| 218 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3') |
||
| 219 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7') |
||
| 220 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 221 | |||
| 222 | query = IssueQuery.new(:name => '_') |
||
| 223 | query.add_filter("cf_#{f.id}", '=', ['-12.7'])
|
||
| 224 | assert query.valid? |
||
| 225 | issues = find_issues_with_query(query) |
||
| 226 | assert_equal 1, issues.size |
||
| 227 | assert_equal 2, issues.first.id |
||
| 228 | end |
||
| 229 | |||
| 230 | def test_operator_is_on_multi_list_custom_field |
||
| 231 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true, |
||
| 232 | :possible_values => ['value1', 'value2', 'value3'], :multiple => true) |
||
| 233 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1') |
||
| 234 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2') |
||
| 235 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1') |
||
| 236 | |||
| 237 | query = IssueQuery.new(:name => '_') |
||
| 238 | query.add_filter("cf_#{f.id}", '=', ['value1'])
|
||
| 239 | issues = find_issues_with_query(query) |
||
| 240 | assert_equal [1, 3], issues.map(&:id).sort |
||
| 241 | |||
| 242 | query = IssueQuery.new(:name => '_') |
||
| 243 | query.add_filter("cf_#{f.id}", '=', ['value2'])
|
||
| 244 | issues = find_issues_with_query(query) |
||
| 245 | assert_equal [1], issues.map(&:id).sort |
||
| 246 | end |
||
| 247 | |||
| 248 | def test_operator_is_not_on_multi_list_custom_field |
||
| 249 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true, |
||
| 250 | :possible_values => ['value1', 'value2', 'value3'], :multiple => true) |
||
| 251 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1') |
||
| 252 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2') |
||
| 253 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1') |
||
| 254 | |||
| 255 | query = IssueQuery.new(:name => '_') |
||
| 256 | query.add_filter("cf_#{f.id}", '!', ['value1'])
|
||
| 257 | issues = find_issues_with_query(query) |
||
| 258 | assert !issues.map(&:id).include?(1) |
||
| 259 | assert !issues.map(&:id).include?(3) |
||
| 260 | |||
| 261 | query = IssueQuery.new(:name => '_') |
||
| 262 | query.add_filter("cf_#{f.id}", '!', ['value2'])
|
||
| 263 | issues = find_issues_with_query(query) |
||
| 264 | assert !issues.map(&:id).include?(1) |
||
| 265 | assert issues.map(&:id).include?(3) |
||
| 266 | end |
||
| 267 | |||
| 268 | def test_operator_is_on_is_private_field |
||
| 269 | # is_private filter only available for those who can set issues private |
||
| 270 | User.current = User.find(2) |
||
| 271 | |||
| 272 | query = IssueQuery.new(:name => '_') |
||
| 273 | assert query.available_filters.key?('is_private')
|
||
| 274 | |||
| 275 | query.add_filter("is_private", '=', ['1'])
|
||
| 276 | issues = find_issues_with_query(query) |
||
| 277 | assert issues.any? |
||
| 278 | assert_nil issues.detect {|issue| !issue.is_private?}
|
||
| 279 | ensure |
||
| 280 | User.current = nil |
||
| 281 | end |
||
| 282 | |||
| 283 | def test_operator_is_not_on_is_private_field |
||
| 284 | # is_private filter only available for those who can set issues private |
||
| 285 | User.current = User.find(2) |
||
| 286 | |||
| 287 | query = IssueQuery.new(:name => '_') |
||
| 288 | assert query.available_filters.key?('is_private')
|
||
| 289 | |||
| 290 | query.add_filter("is_private", '!', ['1'])
|
||
| 291 | issues = find_issues_with_query(query) |
||
| 292 | assert issues.any? |
||
| 293 | assert_nil issues.detect {|issue| issue.is_private?}
|
||
| 294 | ensure |
||
| 295 | User.current = nil |
||
| 296 | end |
||
| 297 | |||
| 298 | def test_operator_greater_than |
||
| 299 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 300 | query.add_filter('done_ratio', '>=', ['40'])
|
||
| 301 | assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")
|
||
| 302 | find_issues_with_query(query) |
||
| 303 | end |
||
| 304 | |||
| 305 | def test_operator_greater_than_a_float |
||
| 306 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 307 | query.add_filter('estimated_hours', '>=', ['40.5'])
|
||
| 308 | assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")
|
||
| 309 | find_issues_with_query(query) |
||
| 310 | end |
||
| 311 | |||
| 312 | def test_operator_greater_than_on_int_custom_field |
||
| 313 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true) |
||
| 314 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7') |
||
| 315 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12') |
||
| 316 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 317 | |||
| 318 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 319 | query.add_filter("cf_#{f.id}", '>=', ['8'])
|
||
| 320 | issues = find_issues_with_query(query) |
||
| 321 | assert_equal 1, issues.size |
||
| 322 | assert_equal 2, issues.first.id |
||
| 323 | end |
||
| 324 | |||
| 325 | def test_operator_lesser_than |
||
| 326 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 327 | query.add_filter('done_ratio', '<=', ['30'])
|
||
| 328 | assert query.statement.include?("#{Issue.table_name}.done_ratio <= 30.0")
|
||
| 329 | find_issues_with_query(query) |
||
| 330 | end |
||
| 331 | |||
| 332 | def test_operator_lesser_than_on_custom_field |
||
| 333 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true) |
||
| 334 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 335 | query.add_filter("cf_#{f.id}", '<=', ['30'])
|
||
| 336 | assert_match /CAST.+ <= 30\.0/, query.statement |
||
| 337 | find_issues_with_query(query) |
||
| 338 | end |
||
| 339 | |||
| 340 | def test_operator_lesser_than_on_date_custom_field |
||
| 341 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'date', :is_filter => true, :is_for_all => true) |
||
| 342 | CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '2013-04-11') |
||
| 343 | CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '2013-05-14') |
||
| 344 | CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '') |
||
| 345 | |||
| 346 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 347 | query.add_filter("cf_#{f.id}", '<=', ['2013-05-01'])
|
||
| 348 | issue_ids = find_issues_with_query(query).map(&:id) |
||
| 349 | assert_include 1, issue_ids |
||
| 350 | assert_not_include 2, issue_ids |
||
| 351 | assert_not_include 3, issue_ids |
||
| 352 | end |
||
| 353 | |||
| 354 | def test_operator_between |
||
| 355 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 356 | query.add_filter('done_ratio', '><', ['30', '40'])
|
||
| 357 | assert_include "#{Issue.table_name}.done_ratio BETWEEN 30.0 AND 40.0", query.statement
|
||
| 358 | find_issues_with_query(query) |
||
| 359 | end |
||
| 360 | |||
| 361 | def test_operator_between_on_custom_field |
||
| 362 | f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true) |
||
| 363 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 364 | query.add_filter("cf_#{f.id}", '><', ['30', '40'])
|
||
| 365 | assert_match /CAST.+ BETWEEN 30.0 AND 40.0/, query.statement |
||
| 366 | find_issues_with_query(query) |
||
| 367 | end |
||
| 368 | |||
| 369 | def test_date_filter_should_not_accept_non_date_values |
||
| 370 | query = IssueQuery.new(:name => '_') |
||
| 371 | query.add_filter('created_on', '=', ['a'])
|
||
| 372 | |||
| 373 | assert query.has_filter?('created_on')
|
||
| 374 | assert !query.valid? |
||
| 375 | end |
||
| 376 | |||
| 377 | def test_date_filter_should_not_accept_invalid_date_values |
||
| 378 | query = IssueQuery.new(:name => '_') |
||
| 379 | query.add_filter('created_on', '=', ['2011-01-34'])
|
||
| 380 | |||
| 381 | assert query.has_filter?('created_on')
|
||
| 382 | assert !query.valid? |
||
| 383 | end |
||
| 384 | |||
| 385 | def test_relative_date_filter_should_not_accept_non_integer_values |
||
| 386 | query = IssueQuery.new(:name => '_') |
||
| 387 | query.add_filter('created_on', '>t-', ['a'])
|
||
| 388 | |||
| 389 | assert query.has_filter?('created_on')
|
||
| 390 | assert !query.valid? |
||
| 391 | end |
||
| 392 | |||
| 393 | def test_operator_date_equals |
||
| 394 | query = IssueQuery.new(:name => '_') |
||
| 395 | query.add_filter('due_date', '=', ['2011-07-10'])
|
||
| 396 | assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?' AND issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement |
||
| 397 | find_issues_with_query(query) |
||
| 398 | end |
||
| 399 | |||
| 400 | def test_operator_date_lesser_than |
||
| 401 | query = IssueQuery.new(:name => '_') |
||
| 402 | query.add_filter('due_date', '<=', ['2011-07-10'])
|
||
| 403 | assert_match /issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement |
||
| 404 | find_issues_with_query(query) |
||
| 405 | end |
||
| 406 | |||
| 407 | def test_operator_date_greater_than |
||
| 408 | query = IssueQuery.new(:name => '_') |
||
| 409 | query.add_filter('due_date', '>=', ['2011-07-10'])
|
||
| 410 | assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?'/, query.statement |
||
| 411 | find_issues_with_query(query) |
||
| 412 | end |
||
| 413 | |||
| 414 | def test_operator_date_between |
||
| 415 | query = IssueQuery.new(:name => '_') |
||
| 416 | query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])
|
||
| 417 | assert_match /issues\.due_date > '2011-06-22 23:59:59(\.9+)?' AND issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement |
||
| 418 | find_issues_with_query(query) |
||
| 419 | end |
||
| 420 | |||
| 421 | def test_operator_in_more_than |
||
| 422 | Issue.find(7).update_attribute(:due_date, (Date.today + 15)) |
||
| 423 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 424 | query.add_filter('due_date', '>t+', ['15'])
|
||
| 425 | issues = find_issues_with_query(query) |
||
| 426 | assert !issues.empty? |
||
| 427 | issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}
|
||
| 428 | end |
||
| 429 | |||
| 430 | def test_operator_in_less_than |
||
| 431 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 432 | query.add_filter('due_date', '<t+', ['15'])
|
||
| 433 | issues = find_issues_with_query(query) |
||
| 434 | assert !issues.empty? |
||
| 435 | issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}
|
||
| 436 | end |
||
| 437 | |||
| 438 | def test_operator_in_the_next_days |
||
| 439 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 440 | query.add_filter('due_date', '><t+', ['15'])
|
||
| 441 | issues = find_issues_with_query(query) |
||
| 442 | assert !issues.empty? |
||
| 443 | issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
|
||
| 444 | end |
||
| 445 | |||
| 446 | def test_operator_less_than_ago |
||
| 447 | Issue.find(7).update_attribute(:due_date, (Date.today - 3)) |
||
| 448 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 449 | query.add_filter('due_date', '>t-', ['3'])
|
||
| 450 | issues = find_issues_with_query(query) |
||
| 451 | assert !issues.empty? |
||
| 452 | issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}
|
||
| 453 | end |
||
| 454 | |||
| 455 | def test_operator_in_the_past_days |
||
| 456 | Issue.find(7).update_attribute(:due_date, (Date.today - 3)) |
||
| 457 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 458 | query.add_filter('due_date', '><t-', ['3'])
|
||
| 459 | issues = find_issues_with_query(query) |
||
| 460 | assert !issues.empty? |
||
| 461 | issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
|
||
| 462 | end |
||
| 463 | |||
| 464 | def test_operator_more_than_ago |
||
| 465 | Issue.find(7).update_attribute(:due_date, (Date.today - 10)) |
||
| 466 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 467 | query.add_filter('due_date', '<t-', ['10'])
|
||
| 468 | assert query.statement.include?("#{Issue.table_name}.due_date <=")
|
||
| 469 | issues = find_issues_with_query(query) |
||
| 470 | assert !issues.empty? |
||
| 471 | issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}
|
||
| 472 | end |
||
| 473 | |||
| 474 | def test_operator_in |
||
| 475 | Issue.find(7).update_attribute(:due_date, (Date.today + 2)) |
||
| 476 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 477 | query.add_filter('due_date', 't+', ['2'])
|
||
| 478 | issues = find_issues_with_query(query) |
||
| 479 | assert !issues.empty? |
||
| 480 | issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}
|
||
| 481 | end |
||
| 482 | |||
| 483 | def test_operator_ago |
||
| 484 | Issue.find(7).update_attribute(:due_date, (Date.today - 3)) |
||
| 485 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 486 | query.add_filter('due_date', 't-', ['3'])
|
||
| 487 | issues = find_issues_with_query(query) |
||
| 488 | assert !issues.empty? |
||
| 489 | issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}
|
||
| 490 | end |
||
| 491 | |||
| 492 | def test_operator_today |
||
| 493 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 494 | query.add_filter('due_date', 't', [''])
|
||
| 495 | issues = find_issues_with_query(query) |
||
| 496 | assert !issues.empty? |
||
| 497 | issues.each {|issue| assert_equal Date.today, issue.due_date}
|
||
| 498 | end |
||
| 499 | |||
| 500 | def test_operator_this_week_on_date |
||
| 501 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 502 | query.add_filter('due_date', 'w', [''])
|
||
| 503 | find_issues_with_query(query) |
||
| 504 | end |
||
| 505 | |||
| 506 | def test_operator_this_week_on_datetime |
||
| 507 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 508 | query.add_filter('created_on', 'w', [''])
|
||
| 509 | find_issues_with_query(query) |
||
| 510 | end |
||
| 511 | |||
| 512 | def test_operator_contains |
||
| 513 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 514 | query.add_filter('subject', '~', ['uNable'])
|
||
| 515 | assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")
|
||
| 516 | result = find_issues_with_query(query) |
||
| 517 | assert result.empty? |
||
| 518 | result.each {|issue| assert issue.subject.downcase.include?('unable') }
|
||
| 519 | end |
||
| 520 | |||
| 521 | def test_range_for_this_week_with_week_starting_on_monday |
||
| 522 | I18n.locale = :fr |
||
| 523 | assert_equal '1', I18n.t(:general_first_day_of_week) |
||
| 524 | |||
| 525 | Date.stubs(:today).returns(Date.parse('2011-04-29'))
|
||
| 526 | |||
| 527 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 528 | query.add_filter('due_date', 'w', [''])
|
||
| 529 | assert query.statement.match(/issues\.due_date > '2011-04-24 23:59:59(\.9+)?' AND issues\.due_date <= '2011-05-01 23:59:59(\.9+)?/), "range not found in #{query.statement}"
|
||
| 530 | I18n.locale = :en |
||
| 531 | end |
||
| 532 | |||
| 533 | def test_range_for_this_week_with_week_starting_on_sunday |
||
| 534 | I18n.locale = :en |
||
| 535 | assert_equal '7', I18n.t(:general_first_day_of_week) |
||
| 536 | |||
| 537 | Date.stubs(:today).returns(Date.parse('2011-04-29'))
|
||
| 538 | |||
| 539 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 540 | query.add_filter('due_date', 'w', [''])
|
||
| 541 | assert query.statement.match(/issues\.due_date > '2011-04-23 23:59:59(\.9+)?' AND issues\.due_date <= '2011-04-30 23:59:59(\.9+)?/), "range not found in #{query.statement}"
|
||
| 542 | end |
||
| 543 | |||
| 544 | def test_operator_does_not_contains |
||
| 545 | query = IssueQuery.new(:project => Project.find(1), :name => '_') |
||
| 546 | query.add_filter('subject', '!~', ['uNable'])
|
||
| 547 | assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")
|
||
| 548 | find_issues_with_query(query) |
||
| 549 | end |
||
| 550 | |||
| 551 | def test_filter_assigned_to_me |
||
| 552 | user = User.find(2) |
||
| 553 | group = Group.find(10) |
||
| 554 | User.current = user |
||
| 555 | i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user) |
||
| 556 | i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group) |
||
| 557 | i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => Group.find(11)) |
||
| 558 | group.users << user |
||
| 559 | |||
| 560 | query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
|
||
| 561 | result = query.issues |
||
| 562 | assert_equal Issue.visible.all(:conditions => {:assigned_to_id => ([2] + user.reload.group_ids)}).sort_by(&:id), result.sort_by(&:id)
|
||
| 563 | |||
| 564 | assert result.include?(i1) |
||
| 565 | assert result.include?(i2) |
||
| 566 | assert !result.include?(i3) |
||
| 567 | end |
||
| 568 | |||
| 569 | def test_user_custom_field_filtered_on_me |
||
| 570 | User.current = User.find(2) |
||
| 571 | cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1]) |
||
| 572 | issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)
|
||
| 573 | issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})
|
||
| 574 | |||
| 575 | query = IssueQuery.new(:name => '_', :project => Project.find(1)) |
||
| 576 | filter = query.available_filters["cf_#{cf.id}"]
|
||
| 577 | assert_not_nil filter |
||
| 578 | assert_include 'me', filter[:values].map{|v| v[1]}
|
||
| 579 | |||
| 580 | query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}
|
||
| 581 | result = query.issues |
||
| 582 | assert_equal 1, result.size |
||
| 583 | assert_equal issue1, result.first |
||
| 584 | end |
||
| 585 | |||
| 586 | def test_filter_my_projects |
||
| 587 | User.current = User.find(2) |
||
| 588 | query = IssueQuery.new(:name => '_') |
||
| 589 | filter = query.available_filters['project_id'] |
||
| 590 | assert_not_nil filter |
||
| 591 | assert_include 'mine', filter[:values].map{|v| v[1]}
|
||
| 592 | |||
| 593 | query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}
|
||
| 594 | result = query.issues |
||
| 595 | assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}
|
||
| 596 | end |
||
| 597 | |||
| 598 | def test_filter_watched_issues |
||
| 599 | User.current = User.find(1) |
||
| 600 | query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
|
||
| 601 | result = find_issues_with_query(query) |
||
| 602 | assert_not_nil result |
||
| 603 | assert !result.empty? |
||
| 604 | assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id) |
||
| 605 | User.current = nil |
||
| 606 | end |
||
| 607 | |||
| 608 | def test_filter_unwatched_issues |
||
| 609 | User.current = User.find(1) |
||
| 610 | query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})
|
||
| 611 | result = find_issues_with_query(query) |
||
| 612 | assert_not_nil result |
||
| 613 | assert !result.empty? |
||
| 614 | assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size) |
||
| 615 | User.current = nil |
||
| 616 | end |
||
| 617 | |||
| 618 | def test_filter_on_project_custom_field |
||
| 619 | field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string') |
||
| 620 | CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo') |
||
| 621 | CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo') |
||
| 622 | |||
| 623 | query = IssueQuery.new(:name => '_') |
||
| 624 | filter_name = "project.cf_#{field.id}"
|
||
| 625 | assert_include filter_name, query.available_filters.keys |
||
| 626 | query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
|
||
| 627 | assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort |
||
| 628 | end |
||
| 629 | |||
| 630 | def test_filter_on_author_custom_field |
||
| 631 | field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string') |
||
| 632 | CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo') |
||
| 633 | |||
| 634 | query = IssueQuery.new(:name => '_') |
||
| 635 | filter_name = "author.cf_#{field.id}"
|
||
| 636 | assert_include filter_name, query.available_filters.keys |
||
| 637 | query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
|
||
| 638 | assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort |
||
| 639 | end |
||
| 640 | |||
| 641 | def test_filter_on_assigned_to_custom_field |
||
| 642 | field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string') |
||
| 643 | CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo') |
||
| 644 | |||
| 645 | query = IssueQuery.new(:name => '_') |
||
| 646 | filter_name = "assigned_to.cf_#{field.id}"
|
||
| 647 | assert_include filter_name, query.available_filters.keys |
||
| 648 | query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
|
||
| 649 | assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort |
||
| 650 | end |
||
| 651 | |||
| 652 | def test_filter_on_fixed_version_custom_field |
||
| 653 | field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string') |
||
| 654 | CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo') |
||
| 655 | |||
| 656 | query = IssueQuery.new(:name => '_') |
||
| 657 | filter_name = "fixed_version.cf_#{field.id}"
|
||
| 658 | assert_include filter_name, query.available_filters.keys |
||
| 659 | query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
|
||
| 660 | assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort |
||
| 661 | end |
||
| 662 | |||
| 663 | def test_filter_on_relations_with_a_specific_issue |
||
| 664 | IssueRelation.delete_all |
||
| 665 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2)) |
||
| 666 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1)) |
||
| 667 | |||
| 668 | query = IssueQuery.new(:name => '_') |
||
| 669 | query.filters = {"relates" => {:operator => '=', :values => ['1']}}
|
||
| 670 | assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort |
||
| 671 | |||
| 672 | query = IssueQuery.new(:name => '_') |
||
| 673 | query.filters = {"relates" => {:operator => '=', :values => ['2']}}
|
||
| 674 | assert_equal [1], find_issues_with_query(query).map(&:id).sort |
||
| 675 | end |
||
| 676 | |||
| 677 | def test_filter_on_relations_with_any_issues_in_a_project |
||
| 678 | IssueRelation.delete_all |
||
| 679 | with_settings :cross_project_issue_relations => '1' do |
||
| 680 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first) |
||
| 681 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first) |
||
| 682 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first) |
||
| 683 | end |
||
| 684 | |||
| 685 | query = IssueQuery.new(:name => '_') |
||
| 686 | query.filters = {"relates" => {:operator => '=p', :values => ['2']}}
|
||
| 687 | assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort |
||
| 688 | |||
| 689 | query = IssueQuery.new(:name => '_') |
||
| 690 | query.filters = {"relates" => {:operator => '=p', :values => ['3']}}
|
||
| 691 | assert_equal [1], find_issues_with_query(query).map(&:id).sort |
||
| 692 | |||
| 693 | query = IssueQuery.new(:name => '_') |
||
| 694 | query.filters = {"relates" => {:operator => '=p', :values => ['4']}}
|
||
| 695 | assert_equal [], find_issues_with_query(query).map(&:id).sort |
||
| 696 | end |
||
| 697 | |||
| 698 | def test_filter_on_relations_with_any_issues_not_in_a_project |
||
| 699 | IssueRelation.delete_all |
||
| 700 | with_settings :cross_project_issue_relations => '1' do |
||
| 701 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first) |
||
| 702 | #IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first) |
||
| 703 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first) |
||
| 704 | end |
||
| 705 | |||
| 706 | query = IssueQuery.new(:name => '_') |
||
| 707 | query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}
|
||
| 708 | assert_equal [1], find_issues_with_query(query).map(&:id).sort |
||
| 709 | end |
||
| 710 | |||
| 711 | def test_filter_on_relations_with_no_issues_in_a_project |
||
| 712 | IssueRelation.delete_all |
||
| 713 | with_settings :cross_project_issue_relations => '1' do |
||
| 714 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first) |
||
| 715 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first) |
||
| 716 | IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3)) |
||
| 717 | end |
||
| 718 | |||
| 719 | query = IssueQuery.new(:name => '_') |
||
| 720 | query.filters = {"relates" => {:operator => '!p', :values => ['2']}}
|
||
| 721 | ids = find_issues_with_query(query).map(&:id).sort |
||
| 722 | assert_include 2, ids |
||
| 723 | assert_not_include 1, ids |
||
| 724 | assert_not_include 3, ids |
||
| 725 | end |
||
| 726 | |||
| 727 | def test_filter_on_relations_with_no_issues |
||
| 728 | IssueRelation.delete_all |
||
| 729 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2)) |
||
| 730 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1)) |
||
| 731 | |||
| 732 | query = IssueQuery.new(:name => '_') |
||
| 733 | query.filters = {"relates" => {:operator => '!*', :values => ['']}}
|
||
| 734 | ids = find_issues_with_query(query).map(&:id) |
||
| 735 | assert_equal [], ids & [1, 2, 3] |
||
| 736 | assert_include 4, ids |
||
| 737 | end |
||
| 738 | |||
| 739 | def test_filter_on_relations_with_any_issues |
||
| 740 | IssueRelation.delete_all |
||
| 741 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2)) |
||
| 742 | IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1)) |
||
| 743 | |||
| 744 | query = IssueQuery.new(:name => '_') |
||
| 745 | query.filters = {"relates" => {:operator => '*', :values => ['']}}
|
||
| 746 | assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort |
||
| 747 | end |
||
| 748 | |||
| 749 | def test_statement_should_be_nil_with_no_filters |
||
| 750 | q = IssueQuery.new(:name => '_') |
||
| 751 | q.filters = {}
|
||
| 752 | |||
| 753 | assert q.valid? |
||
| 754 | assert_nil q.statement |
||
| 755 | end |
||
| 756 | |||
| 757 | def test_default_columns |
||
| 758 | q = IssueQuery.new |
||
| 759 | assert q.columns.any? |
||
| 760 | assert q.inline_columns.any? |
||
| 761 | assert q.block_columns.empty? |
||
| 762 | end |
||
| 763 | |||
| 764 | def test_set_column_names |
||
| 765 | q = IssueQuery.new |
||
| 766 | q.column_names = ['tracker', :subject, '', 'unknonw_column'] |
||
| 767 | assert_equal [:id, :tracker, :subject], q.columns.collect {|c| c.name}
|
||
| 768 | end |
||
| 769 | |||
| 770 | def test_has_column_should_accept_a_column_name |
||
| 771 | q = IssueQuery.new |
||
| 772 | q.column_names = ['tracker', :subject] |
||
| 773 | assert q.has_column?(:tracker) |
||
| 774 | assert !q.has_column?(:category) |
||
| 775 | end |
||
| 776 | |||
| 777 | def test_has_column_should_accept_a_column |
||
| 778 | q = IssueQuery.new |
||
| 779 | q.column_names = ['tracker', :subject] |
||
| 780 | |||
| 781 | tracker_column = q.available_columns.detect {|c| c.name==:tracker}
|
||
| 782 | assert_kind_of QueryColumn, tracker_column |
||
| 783 | category_column = q.available_columns.detect {|c| c.name==:category}
|
||
| 784 | assert_kind_of QueryColumn, category_column |
||
| 785 | |||
| 786 | assert q.has_column?(tracker_column) |
||
| 787 | assert !q.has_column?(category_column) |
||
| 788 | end |
||
| 789 | |||
| 790 | def test_inline_and_block_columns |
||
| 791 | q = IssueQuery.new |
||
| 792 | q.column_names = ['subject', 'description', 'tracker'] |
||
| 793 | |||
| 794 | assert_equal [:id, :subject, :tracker], q.inline_columns.map(&:name) |
||
| 795 | assert_equal [:description], q.block_columns.map(&:name) |
||
| 796 | end |
||
| 797 | |||
| 798 | def test_custom_field_columns_should_be_inline |
||
| 799 | q = IssueQuery.new |
||
| 800 | columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}
|
||
| 801 | assert columns.any? |
||
| 802 | assert_nil columns.detect {|column| !column.inline?}
|
||
| 803 | end |
||
| 804 | |||
| 805 | def test_query_should_preload_spent_hours |
||
| 806 | q = IssueQuery.new(:name => '_', :column_names => [:subject, :spent_hours]) |
||
| 807 | assert q.has_column?(:spent_hours) |
||
| 808 | issues = q.issues |
||
| 809 | assert_not_nil issues.first.instance_variable_get("@spent_hours")
|
||
| 810 | end |
||
| 811 | |||
| 812 | def test_groupable_columns_should_include_custom_fields |
||
| 813 | q = IssueQuery.new |
||
| 814 | column = q.groupable_columns.detect {|c| c.name == :cf_1}
|
||
| 815 | assert_not_nil column |
||
| 816 | assert_kind_of QueryCustomFieldColumn, column |
||
| 817 | end |
||
| 818 | |||
| 819 | def test_groupable_columns_should_not_include_multi_custom_fields |
||
| 820 | field = CustomField.find(1) |
||
| 821 | field.update_attribute :multiple, true |
||
| 822 | |||
| 823 | q = IssueQuery.new |
||
| 824 | column = q.groupable_columns.detect {|c| c.name == :cf_1}
|
||
| 825 | assert_nil column |
||
| 826 | end |
||
| 827 | |||
| 828 | def test_groupable_columns_should_include_user_custom_fields |
||
| 829 | cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user') |
||
| 830 | |||
| 831 | q = IssueQuery.new |
||
| 832 | assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
|
||
| 833 | end |
||
| 834 | |||
| 835 | def test_groupable_columns_should_include_version_custom_fields |
||
| 836 | cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version') |
||
| 837 | |||
| 838 | q = IssueQuery.new |
||
| 839 | assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
|
||
| 840 | end |
||
| 841 | |||
| 842 | def test_grouped_with_valid_column |
||
| 843 | q = IssueQuery.new(:group_by => 'status') |
||
| 844 | assert q.grouped? |
||
| 845 | assert_not_nil q.group_by_column |
||
| 846 | assert_equal :status, q.group_by_column.name |
||
| 847 | assert_not_nil q.group_by_statement |
||
| 848 | assert_equal 'status', q.group_by_statement |
||
| 849 | end |
||
| 850 | |||
| 851 | def test_grouped_with_invalid_column |
||
| 852 | q = IssueQuery.new(:group_by => 'foo') |
||
| 853 | assert !q.grouped? |
||
| 854 | assert_nil q.group_by_column |
||
| 855 | assert_nil q.group_by_statement |
||
| 856 | end |
||
| 857 | |||
| 858 | def test_sortable_columns_should_sort_assignees_according_to_user_format_setting |
||
| 859 | with_settings :user_format => 'lastname_coma_firstname' do |
||
| 860 | q = IssueQuery.new |
||
| 861 | assert q.sortable_columns.has_key?('assigned_to')
|
||
| 862 | assert_equal %w(users.lastname users.firstname users.id), q.sortable_columns['assigned_to'] |
||
| 863 | end |
||
| 864 | end |
||
| 865 | |||
| 866 | def test_sortable_columns_should_sort_authors_according_to_user_format_setting |
||
| 867 | with_settings :user_format => 'lastname_coma_firstname' do |
||
| 868 | q = IssueQuery.new |
||
| 869 | assert q.sortable_columns.has_key?('author')
|
||
| 870 | assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author'] |
||
| 871 | end |
||
| 872 | end |
||
| 873 | |||
| 874 | def test_sortable_columns_should_include_custom_field |
||
| 875 | q = IssueQuery.new |
||
| 876 | assert q.sortable_columns['cf_1'] |
||
| 877 | end |
||
| 878 | |||
| 879 | def test_sortable_columns_should_not_include_multi_custom_field |
||
| 880 | field = CustomField.find(1) |
||
| 881 | field.update_attribute :multiple, true |
||
| 882 | |||
| 883 | q = IssueQuery.new |
||
| 884 | assert !q.sortable_columns['cf_1'] |
||
| 885 | end |
||
| 886 | |||
| 887 | def test_default_sort |
||
| 888 | q = IssueQuery.new |
||
| 889 | assert_equal [], q.sort_criteria |
||
| 890 | end |
||
| 891 | |||
| 892 | def test_set_sort_criteria_with_hash |
||
| 893 | q = IssueQuery.new |
||
| 894 | q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}
|
||
| 895 | assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria |
||
| 896 | end |
||
| 897 | |||
| 898 | def test_set_sort_criteria_with_array |
||
| 899 | q = IssueQuery.new |
||
| 900 | q.sort_criteria = [['priority', 'desc'], 'tracker'] |
||
| 901 | assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria |
||
| 902 | end |
||
| 903 | |||
| 904 | def test_create_query_with_sort |
||
| 905 | q = IssueQuery.new(:name => 'Sorted') |
||
| 906 | q.sort_criteria = [['priority', 'desc'], 'tracker'] |
||
| 907 | assert q.save |
||
| 908 | q.reload |
||
| 909 | assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria |
||
| 910 | end |
||
| 911 | |||
| 912 | def test_sort_by_string_custom_field_asc |
||
| 913 | q = IssueQuery.new |
||
| 914 | c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
|
||
| 915 | assert c |
||
| 916 | assert c.sortable |
||
| 917 | issues = q.issues(:order => "#{c.sortable} ASC")
|
||
| 918 | values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
|
||
| 919 | assert !values.empty? |
||
| 920 | assert_equal values.sort, values |
||
| 921 | end |
||
| 922 | |||
| 923 | def test_sort_by_string_custom_field_desc |
||
| 924 | q = IssueQuery.new |
||
| 925 | c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
|
||
| 926 | assert c |
||
| 927 | assert c.sortable |
||
| 928 | issues = q.issues(:order => "#{c.sortable} DESC")
|
||
| 929 | values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
|
||
| 930 | assert !values.empty? |
||
| 931 | assert_equal values.sort.reverse, values |
||
| 932 | end |
||
| 933 | |||
| 934 | def test_sort_by_float_custom_field_asc |
||
| 935 | q = IssueQuery.new |
||
| 936 | c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }
|
||
| 937 | assert c |
||
| 938 | assert c.sortable |
||
| 939 | issues = q.issues(:order => "#{c.sortable} ASC")
|
||
| 940 | values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact
|
||
| 941 | assert !values.empty? |
||
| 942 | assert_equal values.sort, values |
||
| 943 | end |
||
| 944 | |||
| 945 | def test_invalid_query_should_raise_query_statement_invalid_error |
||
| 946 | q = IssueQuery.new |
||
| 947 | assert_raise Query::StatementInvalid do |
||
| 948 | q.issues(:conditions => "foo = 1") |
||
| 949 | end |
||
| 950 | end |
||
| 951 | |||
| 952 | def test_issue_count |
||
| 953 | q = IssueQuery.new(:name => '_') |
||
| 954 | issue_count = q.issue_count |
||
| 955 | assert_equal q.issues.size, issue_count |
||
| 956 | end |
||
| 957 | |||
| 958 | def test_issue_count_with_archived_issues |
||
| 959 | p = Project.generate! do |project| |
||
| 960 | project.status = Project::STATUS_ARCHIVED |
||
| 961 | end |
||
| 962 | i = Issue.generate!( :project => p, :tracker => p.trackers.first ) |
||
| 963 | assert !i.visible? |
||
| 964 | |||
| 965 | test_issue_count |
||
| 966 | end |
||
| 967 | |||
| 968 | def test_issue_count_by_association_group |
||
| 969 | q = IssueQuery.new(:name => '_', :group_by => 'assigned_to') |
||
| 970 | count_by_group = q.issue_count_by_group |
||
| 971 | assert_kind_of Hash, count_by_group |
||
| 972 | assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
|
||
| 973 | assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
|
||
| 974 | assert count_by_group.has_key?(User.find(3)) |
||
| 975 | end |
||
| 976 | |||
| 977 | def test_issue_count_by_list_custom_field_group |
||
| 978 | q = IssueQuery.new(:name => '_', :group_by => 'cf_1') |
||
| 979 | count_by_group = q.issue_count_by_group |
||
| 980 | assert_kind_of Hash, count_by_group |
||
| 981 | assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
|
||
| 982 | assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
|
||
| 983 | assert count_by_group.has_key?('MySQL')
|
||
| 984 | end |
||
| 985 | |||
| 986 | def test_issue_count_by_date_custom_field_group |
||
| 987 | q = IssueQuery.new(:name => '_', :group_by => 'cf_8') |
||
| 988 | count_by_group = q.issue_count_by_group |
||
| 989 | assert_kind_of Hash, count_by_group |
||
| 990 | assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
|
||
| 991 | assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
|
||
| 992 | end |
||
| 993 | |||
| 994 | def test_issue_count_with_nil_group_only |
||
| 995 | Issue.update_all("assigned_to_id = NULL")
|
||
| 996 | |||
| 997 | q = IssueQuery.new(:name => '_', :group_by => 'assigned_to') |
||
| 998 | count_by_group = q.issue_count_by_group |
||
| 999 | assert_kind_of Hash, count_by_group |
||
| 1000 | assert_equal 1, count_by_group.keys.size |
||
| 1001 | assert_nil count_by_group.keys.first |
||
| 1002 | end |
||
| 1003 | |||
| 1004 | def test_issue_ids |
||
| 1005 | q = IssueQuery.new(:name => '_') |
||
| 1006 | order = "issues.subject, issues.id" |
||
| 1007 | issues = q.issues(:order => order) |
||
| 1008 | assert_equal issues.map(&:id), q.issue_ids(:order => order) |
||
| 1009 | end |
||
| 1010 | |||
| 1011 | def test_label_for |
||
| 1012 | set_language_if_valid 'en' |
||
| 1013 | q = IssueQuery.new |
||
| 1014 | assert_equal 'Assignee', q.label_for('assigned_to_id')
|
||
| 1015 | end |
||
| 1016 | |||
| 1017 | def test_label_for_fr |
||
| 1018 | set_language_if_valid 'fr' |
||
| 1019 | q = IssueQuery.new |
||
| 1020 | s = "Assign\xc3\xa9 \xc3\xa0" |
||
| 1021 | s.force_encoding('UTF-8') if s.respond_to?(:force_encoding)
|
||
| 1022 | assert_equal s, q.label_for('assigned_to_id')
|
||
| 1023 | end |
||
| 1024 | |||
| 1025 | def test_editable_by |
||
| 1026 | admin = User.find(1) |
||
| 1027 | manager = User.find(2) |
||
| 1028 | developer = User.find(3) |
||
| 1029 | |||
| 1030 | # Public query on project 1 |
||
| 1031 | q = IssueQuery.find(1) |
||
| 1032 | assert q.editable_by?(admin) |
||
| 1033 | assert q.editable_by?(manager) |
||
| 1034 | assert !q.editable_by?(developer) |
||
| 1035 | |||
| 1036 | # Private query on project 1 |
||
| 1037 | q = IssueQuery.find(2) |
||
| 1038 | assert q.editable_by?(admin) |
||
| 1039 | assert !q.editable_by?(manager) |
||
| 1040 | assert q.editable_by?(developer) |
||
| 1041 | |||
| 1042 | # Private query for all projects |
||
| 1043 | q = IssueQuery.find(3) |
||
| 1044 | assert q.editable_by?(admin) |
||
| 1045 | assert !q.editable_by?(manager) |
||
| 1046 | assert q.editable_by?(developer) |
||
| 1047 | |||
| 1048 | # Public query for all projects |
||
| 1049 | q = IssueQuery.find(4) |
||
| 1050 | assert q.editable_by?(admin) |
||
| 1051 | assert !q.editable_by?(manager) |
||
| 1052 | assert !q.editable_by?(developer) |
||
| 1053 | end |
||
| 1054 | |||
| 1055 | def test_visible_scope |
||
| 1056 | query_ids = IssueQuery.visible(User.anonymous).map(&:id) |
||
| 1057 | |||
| 1058 | assert query_ids.include?(1), 'public query on public project was not visible' |
||
| 1059 | assert query_ids.include?(4), 'public query for all projects was not visible' |
||
| 1060 | assert !query_ids.include?(2), 'private query on public project was visible' |
||
| 1061 | assert !query_ids.include?(3), 'private query for all projects was visible' |
||
| 1062 | assert !query_ids.include?(7), 'public query on private project was visible' |
||
| 1063 | end |
||
| 1064 | |||
| 1065 | test "#available_filters should include users of visible projects in cross-project view" do |
||
| 1066 | users = IssueQuery.new.available_filters["assigned_to_id"] |
||
| 1067 | assert_not_nil users |
||
| 1068 | assert users[:values].map{|u|u[1]}.include?("3")
|
||
| 1069 | end |
||
| 1070 | |||
| 1071 | test "#available_filters should include users of subprojects" do |
||
| 1072 | user1 = User.generate! |
||
| 1073 | user2 = User.generate! |
||
| 1074 | project = Project.find(1) |
||
| 1075 | Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1]) |
||
| 1076 | |||
| 1077 | users = IssueQuery.new(:project => project).available_filters["assigned_to_id"] |
||
| 1078 | assert_not_nil users |
||
| 1079 | assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)
|
||
| 1080 | assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)
|
||
| 1081 | end |
||
| 1082 | |||
| 1083 | test "#available_filters should include visible projects in cross-project view" do |
||
| 1084 | projects = IssueQuery.new.available_filters["project_id"] |
||
| 1085 | assert_not_nil projects |
||
| 1086 | assert projects[:values].map{|u|u[1]}.include?("1")
|
||
| 1087 | end |
||
| 1088 | |||
| 1089 | test "#available_filters should include 'member_of_group' filter" do |
||
| 1090 | query = IssueQuery.new |
||
| 1091 | assert query.available_filters.keys.include?("member_of_group")
|
||
| 1092 | assert_equal :list_optional, query.available_filters["member_of_group"][:type] |
||
| 1093 | assert query.available_filters["member_of_group"][:values].present? |
||
| 1094 | assert_equal Group.all.sort.map {|g| [g.name, g.id.to_s]},
|
||
| 1095 | query.available_filters["member_of_group"][:values].sort |
||
| 1096 | end |
||
| 1097 | |||
| 1098 | test "#available_filters should include 'assigned_to_role' filter" do |
||
| 1099 | query = IssueQuery.new |
||
| 1100 | assert query.available_filters.keys.include?("assigned_to_role")
|
||
| 1101 | assert_equal :list_optional, query.available_filters["assigned_to_role"][:type] |
||
| 1102 | |||
| 1103 | assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1']) |
||
| 1104 | assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2']) |
||
| 1105 | assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3']) |
||
| 1106 | |||
| 1107 | assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4']) |
||
| 1108 | assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5']) |
||
| 1109 | end |
||
| 1110 | |||
| 1111 | context "#statement" do |
||
| 1112 | context "with 'member_of_group' filter" do |
||
| 1113 | setup do |
||
| 1114 | Group.destroy_all # No fixtures |
||
| 1115 | @user_in_group = User.generate! |
||
| 1116 | @second_user_in_group = User.generate! |
||
| 1117 | @user_in_group2 = User.generate! |
||
| 1118 | @user_not_in_group = User.generate! |
||
| 1119 | |||
| 1120 | @group = Group.generate!.reload |
||
| 1121 | @group.users << @user_in_group |
||
| 1122 | @group.users << @second_user_in_group |
||
| 1123 | |||
| 1124 | @group2 = Group.generate!.reload |
||
| 1125 | @group2.users << @user_in_group2 |
||
| 1126 | |||
| 1127 | end |
||
| 1128 | |||
| 1129 | should "search assigned to for users in the group" do |
||
| 1130 | @query = IssueQuery.new(:name => '_') |
||
| 1131 | @query.add_filter('member_of_group', '=', [@group.id.to_s])
|
||
| 1132 | |||
| 1133 | assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@group.id}')"
|
||
| 1134 | assert_find_issues_with_query_is_successful @query |
||
| 1135 | end |
||
| 1136 | |||
| 1137 | should "search not assigned to any group member (none)" do |
||
| 1138 | @query = IssueQuery.new(:name => '_') |
||
| 1139 | @query.add_filter('member_of_group', '!*', [''])
|
||
| 1140 | |||
| 1141 | # Users not in a group |
||
| 1142 | assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IS NULL OR #{Issue.table_name}.assigned_to_id NOT IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}','#{@group.id}','#{@group2.id}')"
|
||
| 1143 | assert_find_issues_with_query_is_successful @query |
||
| 1144 | end |
||
| 1145 | |||
| 1146 | should "search assigned to any group member (all)" do |
||
| 1147 | @query = IssueQuery.new(:name => '_') |
||
| 1148 | @query.add_filter('member_of_group', '*', [''])
|
||
| 1149 | |||
| 1150 | # Only users in a group |
||
| 1151 | assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@user_in_group2.id}','#{@group.id}','#{@group2.id}')"
|
||
| 1152 | assert_find_issues_with_query_is_successful @query |
||
| 1153 | end |
||
| 1154 | |||
| 1155 | should "return an empty set with = empty group" do |
||
| 1156 | @empty_group = Group.generate! |
||
| 1157 | @query = IssueQuery.new(:name => '_') |
||
| 1158 | @query.add_filter('member_of_group', '=', [@empty_group.id.to_s])
|
||
| 1159 | |||
| 1160 | assert_equal [], find_issues_with_query(@query) |
||
| 1161 | end |
||
| 1162 | |||
| 1163 | should "return issues with ! empty group" do |
||
| 1164 | @empty_group = Group.generate! |
||
| 1165 | @query = IssueQuery.new(:name => '_') |
||
| 1166 | @query.add_filter('member_of_group', '!', [@empty_group.id.to_s])
|
||
| 1167 | |||
| 1168 | assert_find_issues_with_query_is_successful @query |
||
| 1169 | end |
||
| 1170 | end |
||
| 1171 | |||
| 1172 | context "with 'assigned_to_role' filter" do |
||
| 1173 | setup do |
||
| 1174 | @manager_role = Role.find_by_name('Manager')
|
||
| 1175 | @developer_role = Role.find_by_name('Developer')
|
||
| 1176 | |||
| 1177 | @project = Project.generate! |
||
| 1178 | @manager = User.generate! |
||
| 1179 | @developer = User.generate! |
||
| 1180 | @boss = User.generate! |
||
| 1181 | @guest = User.generate! |
||
| 1182 | User.add_to_project(@manager, @project, @manager_role) |
||
| 1183 | User.add_to_project(@developer, @project, @developer_role) |
||
| 1184 | User.add_to_project(@boss, @project, [@manager_role, @developer_role]) |
||
| 1185 | |||
| 1186 | @issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id) |
||
| 1187 | @issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id) |
||
| 1188 | @issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id) |
||
| 1189 | @issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id) |
||
| 1190 | @issue5 = Issue.generate!(:project => @project) |
||
| 1191 | end |
||
| 1192 | |||
| 1193 | should "search assigned to for users with the Role" do |
||
| 1194 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1195 | @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
|
||
| 1196 | |||
| 1197 | assert_query_result [@issue1, @issue3], @query |
||
| 1198 | end |
||
| 1199 | |||
| 1200 | should "search assigned to for users with the Role on the issue project" do |
||
| 1201 | other_project = Project.generate! |
||
| 1202 | User.add_to_project(@developer, other_project, @manager_role) |
||
| 1203 | |||
| 1204 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1205 | @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
|
||
| 1206 | |||
| 1207 | assert_query_result [@issue1, @issue3], @query |
||
| 1208 | end |
||
| 1209 | |||
| 1210 | should "return an empty set with empty role" do |
||
| 1211 | @empty_role = Role.generate! |
||
| 1212 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1213 | @query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])
|
||
| 1214 | |||
| 1215 | assert_query_result [], @query |
||
| 1216 | end |
||
| 1217 | |||
| 1218 | should "search assigned to for users without the Role" do |
||
| 1219 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1220 | @query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])
|
||
| 1221 | |||
| 1222 | assert_query_result [@issue2, @issue4, @issue5], @query |
||
| 1223 | end |
||
| 1224 | |||
| 1225 | should "search assigned to for users not assigned to any Role (none)" do |
||
| 1226 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1227 | @query.add_filter('assigned_to_role', '!*', [''])
|
||
| 1228 | |||
| 1229 | assert_query_result [@issue4, @issue5], @query |
||
| 1230 | end |
||
| 1231 | |||
| 1232 | should "search assigned to for users assigned to any Role (all)" do |
||
| 1233 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1234 | @query.add_filter('assigned_to_role', '*', [''])
|
||
| 1235 | |||
| 1236 | assert_query_result [@issue1, @issue2, @issue3], @query |
||
| 1237 | end |
||
| 1238 | |||
| 1239 | should "return issues with ! empty role" do |
||
| 1240 | @empty_role = Role.generate! |
||
| 1241 | @query = IssueQuery.new(:name => '_', :project => @project) |
||
| 1242 | @query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])
|
||
| 1243 | |||
| 1244 | assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query |
||
| 1245 | end |
||
| 1246 | end |
||
| 1247 | end |
||
| 1248 | end |