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