jro_apps/redmine Commit - r13349:ee173b64b831

1

# Redmine - project management software

1

# Redmine - project management software

2

3

#

3

#

4

# This program is free software; you can redistribute it and/or

4

# This program is free software; you can redistribute it and/or

5

# modify it under the terms of the GNU General Public License

5

# modify it under the terms of the GNU General Public License

6

# as published by the Free Software Foundation; either version 2

6

# as published by the Free Software Foundation; either version 2

7

# of the License, or (at your option) any later version.

7

# of the License, or (at your option) any later version.

8

#

8

#

9

# This program is distributed in the hope that it will be useful,

9

# This program is distributed in the hope that it will be useful,

10

# but WITHOUT ANY WARRANTY; without even the implied warranty of

10

# but WITHOUT ANY WARRANTY; without even the implied warranty of

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12

# GNU General Public License for more details.

12

# GNU General Public License for more details.

13

#

13

#

14

# You should have received a copy of the GNU General Public License

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

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.

16

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

17

18

require File.expand_path('../../test_helper', __FILE__)

18

require File.expand_path('../../test_helper', __FILE__)

19

20

class QueryTest < ActiveSupport::TestCase

20

class QueryTest < ActiveSupport::TestCase

21

include Redmine::I18n

21

include Redmine::I18n

22

23

fixtures :projects, :enabled_modules, :users, :members,

23

fixtures :projects, :enabled_modules, :users, :members,

24

:member_roles, :roles, :trackers, :issue_statuses,

24

:member_roles, :roles, :trackers, :issue_statuses,

25

:issue_categories, :enumerations, :issues,

25

:issue_categories, :enumerations, :issues,

26

:watchers, :custom_fields, :custom_values, :versions,

26

:watchers, :custom_fields, :custom_values, :versions,

27

:queries,

27

:queries,

28

:projects_trackers,

28

:projects_trackers,

29

:custom_fields_trackers,

29

:custom_fields_trackers,

30

:workflows

30

:workflows

31

32

def test_query_with_roles_visibility_should_validate_roles

32

def test_query_with_roles_visibility_should_validate_roles

33

set_language_if_valid 'en'

33

set_language_if_valid 'en'

34

query = IssueQuery.new(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES)

34

query = IssueQuery.new(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES)

35

assert !query.save

35

assert !query.save

36

assert_include "Roles can't be blank", query.errors.full_messages

36

assert_include "Roles can't be blank", query.errors.full_messages

37

query.role_ids = [1, 2]

37

query.role_ids = [1, 2]

38

assert query.save

38

assert query.save

39

end

39

end

40

41

def test_changing_roles_visibility_should_clear_roles

41

def test_changing_roles_visibility_should_clear_roles

42

query = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1, 2])

42

query = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1, 2])

43

assert_equal 2, query.roles.count

43

assert_equal 2, query.roles.count

44

45

query.visibility = IssueQuery::VISIBILITY_PUBLIC

45

query.visibility = IssueQuery::VISIBILITY_PUBLIC

46

query.save!

46

query.save!

47

assert_equal 0, query.roles.count

47

assert_equal 0, query.roles.count

48

end

48

end

49

50

def test_available_filters_should_be_ordered

50

def test_available_filters_should_be_ordered

51

set_language_if_valid 'en'

51

set_language_if_valid 'en'

52

query = IssueQuery.new

52

query = IssueQuery.new

53

assert_equal 0, query.available_filters.keys.index('status_id')

53

assert_equal 0, query.available_filters.keys.index('status_id')

54

expected_order = [

54

expected_order = [

55

"Status",

55

"Status",

56

"Project",

56

"Project",

57

"Tracker",

57

"Tracker",

58

"Priority"

58

"Priority"

59

]

59

]

60

assert_equal expected_order,

60

assert_equal expected_order,

61

(query.available_filters.values.map{|v| v[:name]} & expected_order)

61

(query.available_filters.values.map{|v| v[:name]} & expected_order)

62

end

62

end

63

64

def test_available_filters_with_custom_fields_should_be_ordered

64

def test_available_filters_with_custom_fields_should_be_ordered

65

set_language_if_valid 'en'

65

set_language_if_valid 'en'

66

UserCustomField.create!(

66

UserCustomField.create!(

67

:name => 'order test', :field_format => 'string',

67

:name => 'order test', :field_format => 'string',

68

:is_for_all => true, :is_filter => true

68

:is_for_all => true, :is_filter => true

69

)

69

)

70

query = IssueQuery.new

70

query = IssueQuery.new

71

expected_order = [

71

expected_order = [

72

"Searchable field",

72

"Searchable field",

73

"Database",

73

"Database",

74

"Project's Development status",

74

"Project's Development status",

75

"Author's order test",

75

"Author's order test",

76

"Assignee's order test"

76

"Assignee's order test"

77

]

77

]

78

assert_equal expected_order,

78

assert_equal expected_order,

79

(query.available_filters.values.map{|v| v[:name]} & expected_order)

79

(query.available_filters.values.map{|v| v[:name]} & expected_order)

80

end

80

end

81

82

def test_custom_fields_for_all_projects_should_be_available_in_global_queries

82

def test_custom_fields_for_all_projects_should_be_available_in_global_queries

83

query = IssueQuery.new(:project => nil, :name => '_')

83

query = IssueQuery.new(:project => nil, :name => '_')

84

assert query.available_filters.has_key?('cf_1')

84

assert query.available_filters.has_key?('cf_1')

85

assert !query.available_filters.has_key?('cf_3')

85

assert !query.available_filters.has_key?('cf_3')

86

end

86

end

87

88

def test_system_shared_versions_should_be_available_in_global_queries

88

def test_system_shared_versions_should_be_available_in_global_queries

89

Version.find(2).update_attribute :sharing, 'system'

89

Version.find(2).update_attribute :sharing, 'system'

90

query = IssueQuery.new(:project => nil, :name => '_')

90

query = IssueQuery.new(:project => nil, :name => '_')

91

assert query.available_filters.has_key?('fixed_version_id')

91

assert query.available_filters.has_key?('fixed_version_id')

92

assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}

92

assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}

93

end

93

end

94

95

def test_project_filter_in_global_queries

95

def test_project_filter_in_global_queries

96

query = IssueQuery.new(:project => nil, :name => '_')

96

query = IssueQuery.new(:project => nil, :name => '_')

97

project_filter = query.available_filters["project_id"]

97

project_filter = query.available_filters["project_id"]

98

assert_not_nil project_filter

98

assert_not_nil project_filter

99

project_ids = project_filter[:values].map{|p| p[1]}

99

project_ids = project_filter[:values].map{|p| p[1]}

100

assert project_ids.include?("1") #public project

100

assert project_ids.include?("1") #public project

101

assert !project_ids.include?("2") #private project user cannot see

101

assert !project_ids.include?("2") #private project user cannot see

102

end

102

end

103

104

def test_available_filters_should_not_include_fields_disabled_on_all_trackers

105

Tracker.all.each do |tracker|

106

tracker.core_fields = Tracker::CORE_FIELDS - ['start_date']

107

tracker.save!

108

end

109

110

query = IssueQuery.new(:name => '_')

111

assert_include 'due_date', query.available_filters

112

assert_not_include 'start_date', query.available_filters

113

end

114

104

def find_issues_with_query(query)

115

def find_issues_with_query(query)

105

Issue.joins(:status, :tracker, :project, :priority).where(

116

Issue.joins(:status, :tracker, :project, :priority).where(

106

query.statement

117

query.statement

107

).to_a

118

).to_a

108

end

119

end

109

120

110

def assert_find_issues_with_query_is_successful(query)

121

def assert_find_issues_with_query_is_successful(query)

111

assert_nothing_raised do

122

assert_nothing_raised do

112

find_issues_with_query(query)

123

find_issues_with_query(query)

113

end

124

end

114

end

125

end

115

126

116

def assert_query_statement_includes(query, condition)

127

def assert_query_statement_includes(query, condition)

117

assert_include condition, query.statement

128

assert_include condition, query.statement

118

end

129

end

119

130

120

def assert_query_result(expected, query)

131

def assert_query_result(expected, query)

121

assert_nothing_raised do

132

assert_nothing_raised do

122

assert_equal expected.map(&:id).sort, query.issues.map(&:id).sort

133

assert_equal expected.map(&:id).sort, query.issues.map(&:id).sort

123

assert_equal expected.size, query.issue_count

134

assert_equal expected.size, query.issue_count

124

end

135

end

125

end

136

end

126

137

127

def test_query_should_allow_shared_versions_for_a_project_query

138

def test_query_should_allow_shared_versions_for_a_project_query

128

subproject_version = Version.find(4)

139

subproject_version = Version.find(4)

129

query = IssueQuery.new(:project => Project.find(1), :name => '_')

140

query = IssueQuery.new(:project => Project.find(1), :name => '_')

130

query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])

141

query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])

131

142

132

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")

143

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")

133

end

144

end

134

145

135

def test_query_with_multiple_custom_fields

146

def test_query_with_multiple_custom_fields

136

query = IssueQuery.find(1)

147

query = IssueQuery.find(1)

137

assert query.valid?

148

assert query.valid?

138

assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")

149

assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")

139

issues = find_issues_with_query(query)

150

issues = find_issues_with_query(query)

140

assert_equal 1, issues.length

151

assert_equal 1, issues.length

141

assert_equal Issue.find(3), issues.first

152

assert_equal Issue.find(3), issues.first

142

end

153

end

143

154

144

def test_operator_none

155

def test_operator_none

145

query = IssueQuery.new(:project => Project.find(1), :name => '_')

156

query = IssueQuery.new(:project => Project.find(1), :name => '_')

146

query.add_filter('fixed_version_id', '!*', [''])

157

query.add_filter('fixed_version_id', '!*', [''])

147

query.add_filter('cf_1', '!*', [''])

158

query.add_filter('cf_1', '!*', [''])

148

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")

159

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")

149

assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")

160

assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")

150

find_issues_with_query(query)

161

find_issues_with_query(query)

151

end

162

end

152

163

153

def test_operator_none_for_integer

164

def test_operator_none_for_integer

154

query = IssueQuery.new(:project => Project.find(1), :name => '_')

165

query = IssueQuery.new(:project => Project.find(1), :name => '_')

155

query.add_filter('estimated_hours', '!*', [''])

166

query.add_filter('estimated_hours', '!*', [''])

156

issues = find_issues_with_query(query)

167

issues = find_issues_with_query(query)

157

assert !issues.empty?

168

assert !issues.empty?

158

assert issues.all? {|i| !i.estimated_hours}

169

assert issues.all? {|i| !i.estimated_hours}

159

end

170

end

160

171

161

def test_operator_none_for_date

172

def test_operator_none_for_date

162

query = IssueQuery.new(:project => Project.find(1), :name => '_')

173

query = IssueQuery.new(:project => Project.find(1), :name => '_')

163

query.add_filter('start_date', '!*', [''])

174

query.add_filter('start_date', '!*', [''])

164

issues = find_issues_with_query(query)

175

issues = find_issues_with_query(query)

165

assert !issues.empty?

176

assert !issues.empty?

166

assert issues.all? {|i| i.start_date.nil?}

177

assert issues.all? {|i| i.start_date.nil?}

167

end

178

end

168

179

169

def test_operator_none_for_string_custom_field

180

def test_operator_none_for_string_custom_field

170

query = IssueQuery.new(:project => Project.find(1), :name => '_')

181

query = IssueQuery.new(:project => Project.find(1), :name => '_')

171

query.add_filter('cf_2', '!*', [''])

182

query.add_filter('cf_2', '!*', [''])

172

assert query.has_filter?('cf_2')

183

assert query.has_filter?('cf_2')

173

issues = find_issues_with_query(query)

184

issues = find_issues_with_query(query)

174

assert !issues.empty?

185

assert !issues.empty?

175

assert issues.all? {|i| i.custom_field_value(2).blank?}

186

assert issues.all? {|i| i.custom_field_value(2).blank?}

176

end

187

end

177

188

178

def test_operator_all

189

def test_operator_all

179

query = IssueQuery.new(:project => Project.find(1), :name => '_')

190

query = IssueQuery.new(:project => Project.find(1), :name => '_')

180

query.add_filter('fixed_version_id', '*', [''])

191

query.add_filter('fixed_version_id', '*', [''])

181

query.add_filter('cf_1', '*', [''])

192

query.add_filter('cf_1', '*', [''])

182

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")

193

assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")

183

assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")

194

assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")

184

find_issues_with_query(query)

195

find_issues_with_query(query)

185

end

196

end

186

197

187

def test_operator_all_for_date

198

def test_operator_all_for_date

188

query = IssueQuery.new(:project => Project.find(1), :name => '_')

199

query = IssueQuery.new(:project => Project.find(1), :name => '_')

189

query.add_filter('start_date', '*', [''])

200

query.add_filter('start_date', '*', [''])

190

issues = find_issues_with_query(query)

201

issues = find_issues_with_query(query)

191

assert !issues.empty?

202

assert !issues.empty?

192

assert issues.all? {|i| i.start_date.present?}

203

assert issues.all? {|i| i.start_date.present?}

193

end

204

end

194

205

195

def test_operator_all_for_string_custom_field

206

def test_operator_all_for_string_custom_field

196

query = IssueQuery.new(:project => Project.find(1), :name => '_')

207

query = IssueQuery.new(:project => Project.find(1), :name => '_')

197

query.add_filter('cf_2', '*', [''])

208

query.add_filter('cf_2', '*', [''])

198

assert query.has_filter?('cf_2')

209

assert query.has_filter?('cf_2')

199

issues = find_issues_with_query(query)

210

issues = find_issues_with_query(query)

200

assert !issues.empty?

211

assert !issues.empty?

201

assert issues.all? {|i| i.custom_field_value(2).present?}

212

assert issues.all? {|i| i.custom_field_value(2).present?}

202

end

213

end

203

214

204

def test_numeric_filter_should_not_accept_non_numeric_values

215

def test_numeric_filter_should_not_accept_non_numeric_values

205

query = IssueQuery.new(:name => '_')

216

query = IssueQuery.new(:name => '_')

206

query.add_filter('estimated_hours', '=', ['a'])

217

query.add_filter('estimated_hours', '=', ['a'])

207

218

208

assert query.has_filter?('estimated_hours')

219

assert query.has_filter?('estimated_hours')

209

assert !query.valid?

220

assert !query.valid?

210

end

221

end

211

222

212

def test_operator_is_on_float

223

def test_operator_is_on_float

213

Issue.where(:id => 2).update_all("estimated_hours = 171.2")

224

Issue.where(:id => 2).update_all("estimated_hours = 171.2")

214

query = IssueQuery.new(:name => '_')

225

query = IssueQuery.new(:name => '_')

215

query.add_filter('estimated_hours', '=', ['171.20'])

226

query.add_filter('estimated_hours', '=', ['171.20'])

216

issues = find_issues_with_query(query)

227

issues = find_issues_with_query(query)

217

assert_equal 1, issues.size

228

assert_equal 1, issues.size

218

assert_equal 2, issues.first.id

229

assert_equal 2, issues.first.id

219

end

230

end

220

231

221

def test_operator_is_on_integer_custom_field

232

def test_operator_is_on_integer_custom_field

222

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)

233

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)

223

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

234

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

224

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')

235

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')

225

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

236

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

226

237

227

query = IssueQuery.new(:name => '_')

238

query = IssueQuery.new(:name => '_')

228

query.add_filter("cf_#{f.id}", '=', ['12'])

239

query.add_filter("cf_#{f.id}", '=', ['12'])

229

issues = find_issues_with_query(query)

240

issues = find_issues_with_query(query)

230

assert_equal 1, issues.size

241

assert_equal 1, issues.size

231

assert_equal 2, issues.first.id

242

assert_equal 2, issues.first.id

232

end

243

end

233

244

234

def test_operator_is_on_integer_custom_field_should_accept_negative_value

245

def test_operator_is_on_integer_custom_field_should_accept_negative_value

235

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)

246

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)

236

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

247

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

237

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12')

248

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12')

238

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

249

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

239

250

240

query = IssueQuery.new(:name => '_')

251

query = IssueQuery.new(:name => '_')

241

query.add_filter("cf_#{f.id}", '=', ['-12'])

252

query.add_filter("cf_#{f.id}", '=', ['-12'])

242

assert query.valid?

253

assert query.valid?

243

issues = find_issues_with_query(query)

254

issues = find_issues_with_query(query)

244

assert_equal 1, issues.size

255

assert_equal 1, issues.size

245

assert_equal 2, issues.first.id

256

assert_equal 2, issues.first.id

246

end

257

end

247

258

248

def test_operator_is_on_float_custom_field

259

def test_operator_is_on_float_custom_field

249

f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

260

f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

250

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')

261

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')

251

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7')

262

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7')

252

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

263

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

253

264

254

query = IssueQuery.new(:name => '_')

265

query = IssueQuery.new(:name => '_')

255

query.add_filter("cf_#{f.id}", '=', ['12.7'])

266

query.add_filter("cf_#{f.id}", '=', ['12.7'])

256

issues = find_issues_with_query(query)

267

issues = find_issues_with_query(query)

257

assert_equal 1, issues.size

268

assert_equal 1, issues.size

258

assert_equal 2, issues.first.id

269

assert_equal 2, issues.first.id

259

end

270

end

260

271

261

def test_operator_is_on_float_custom_field_should_accept_negative_value

272

def test_operator_is_on_float_custom_field_should_accept_negative_value

262

f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

273

f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

263

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')

274

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')

264

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7')

275

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7')

265

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

276

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

266

277

267

query = IssueQuery.new(:name => '_')

278

query = IssueQuery.new(:name => '_')

268

query.add_filter("cf_#{f.id}", '=', ['-12.7'])

279

query.add_filter("cf_#{f.id}", '=', ['-12.7'])

269

assert query.valid?

280

assert query.valid?

270

issues = find_issues_with_query(query)

281

issues = find_issues_with_query(query)

271

assert_equal 1, issues.size

282

assert_equal 1, issues.size

272

assert_equal 2, issues.first.id

283

assert_equal 2, issues.first.id

273

end

284

end

274

285

275

def test_operator_is_on_multi_list_custom_field

286

def test_operator_is_on_multi_list_custom_field

276

f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,

287

f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,

277

:possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)

288

:possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)

278

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')

289

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')

279

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')

290

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')

280

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')

291

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')

281

292

282

query = IssueQuery.new(:name => '_')

293

query = IssueQuery.new(:name => '_')

283

query.add_filter("cf_#{f.id}", '=', ['value1'])

294

query.add_filter("cf_#{f.id}", '=', ['value1'])

284

issues = find_issues_with_query(query)

295

issues = find_issues_with_query(query)

285

assert_equal [1, 3], issues.map(&:id).sort

296

assert_equal [1, 3], issues.map(&:id).sort

286

297

287

query = IssueQuery.new(:name => '_')

298

query = IssueQuery.new(:name => '_')

288

query.add_filter("cf_#{f.id}", '=', ['value2'])

299

query.add_filter("cf_#{f.id}", '=', ['value2'])

289

issues = find_issues_with_query(query)

300

issues = find_issues_with_query(query)

290

assert_equal [1], issues.map(&:id).sort

301

assert_equal [1], issues.map(&:id).sort

291

end

302

end

292

303

293

def test_operator_is_not_on_multi_list_custom_field

304

def test_operator_is_not_on_multi_list_custom_field

294

f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,

305

f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,

295

:possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)

306

:possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)

296

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')

307

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')

297

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')

308

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')

298

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')

309

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')

299

310

300

query = IssueQuery.new(:name => '_')

311

query = IssueQuery.new(:name => '_')

301

query.add_filter("cf_#{f.id}", '!', ['value1'])

312

query.add_filter("cf_#{f.id}", '!', ['value1'])

302

issues = find_issues_with_query(query)

313

issues = find_issues_with_query(query)

303

assert !issues.map(&:id).include?(1)

314

assert !issues.map(&:id).include?(1)

304

assert !issues.map(&:id).include?(3)

315

assert !issues.map(&:id).include?(3)

305

316

306

query = IssueQuery.new(:name => '_')

317

query = IssueQuery.new(:name => '_')

307

query.add_filter("cf_#{f.id}", '!', ['value2'])

318

query.add_filter("cf_#{f.id}", '!', ['value2'])

308

issues = find_issues_with_query(query)

319

issues = find_issues_with_query(query)

309

assert !issues.map(&:id).include?(1)

320

assert !issues.map(&:id).include?(1)

310

assert issues.map(&:id).include?(3)

321

assert issues.map(&:id).include?(3)

311

end

322

end

312

323

313

def test_operator_is_on_is_private_field

324

def test_operator_is_on_is_private_field

314

# is_private filter only available for those who can set issues private

325

# is_private filter only available for those who can set issues private

315

User.current = User.find(2)

326

User.current = User.find(2)

316

327

317

query = IssueQuery.new(:name => '_')

328

query = IssueQuery.new(:name => '_')

318

assert query.available_filters.key?('is_private')

329

assert query.available_filters.key?('is_private')

319

330

320

query.add_filter("is_private", '=', ['1'])

331

query.add_filter("is_private", '=', ['1'])

321

issues = find_issues_with_query(query)

332

issues = find_issues_with_query(query)

322

assert issues.any?

333

assert issues.any?

323

assert_nil issues.detect {|issue| !issue.is_private?}

334

assert_nil issues.detect {|issue| !issue.is_private?}

324

ensure

335

ensure

325

User.current = nil

336

User.current = nil

326

end

337

end

327

338

328

def test_operator_is_not_on_is_private_field

339

def test_operator_is_not_on_is_private_field

329

# is_private filter only available for those who can set issues private

340

# is_private filter only available for those who can set issues private

330

User.current = User.find(2)

341

User.current = User.find(2)

331

342

332

query = IssueQuery.new(:name => '_')

343

query = IssueQuery.new(:name => '_')

333

assert query.available_filters.key?('is_private')

344

assert query.available_filters.key?('is_private')

334

345

335

query.add_filter("is_private", '!', ['1'])

346

query.add_filter("is_private", '!', ['1'])

336

issues = find_issues_with_query(query)

347

issues = find_issues_with_query(query)

337

assert issues.any?

348

assert issues.any?

338

assert_nil issues.detect {|issue| issue.is_private?}

349

assert_nil issues.detect {|issue| issue.is_private?}

339

ensure

350

ensure

340

User.current = nil

351

User.current = nil

341

end

352

end

342

353

343

def test_operator_greater_than

354

def test_operator_greater_than

344

query = IssueQuery.new(:project => Project.find(1), :name => '_')

355

query = IssueQuery.new(:project => Project.find(1), :name => '_')

345

query.add_filter('done_ratio', '>=', ['40'])

356

query.add_filter('done_ratio', '>=', ['40'])

346

assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")

357

assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")

347

find_issues_with_query(query)

358

find_issues_with_query(query)

348

end

359

end

349

360

350

def test_operator_greater_than_a_float

361

def test_operator_greater_than_a_float

351

query = IssueQuery.new(:project => Project.find(1), :name => '_')

362

query = IssueQuery.new(:project => Project.find(1), :name => '_')

352

query.add_filter('estimated_hours', '>=', ['40.5'])

363

query.add_filter('estimated_hours', '>=', ['40.5'])

353

assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")

364

assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")

354

find_issues_with_query(query)

365

find_issues_with_query(query)

355

end

366

end

356

367

357

def test_operator_greater_than_on_int_custom_field

368

def test_operator_greater_than_on_int_custom_field

358

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

369

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

359

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

370

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')

360

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')

371

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')

361

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

372

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

362

373

363

query = IssueQuery.new(:project => Project.find(1), :name => '_')

374

query = IssueQuery.new(:project => Project.find(1), :name => '_')

364

query.add_filter("cf_#{f.id}", '>=', ['8'])

375

query.add_filter("cf_#{f.id}", '>=', ['8'])

365

issues = find_issues_with_query(query)

376

issues = find_issues_with_query(query)

366

assert_equal 1, issues.size

377

assert_equal 1, issues.size

367

assert_equal 2, issues.first.id

378

assert_equal 2, issues.first.id

368

end

379

end

369

380

370

def test_operator_lesser_than

381

def test_operator_lesser_than

371

query = IssueQuery.new(:project => Project.find(1), :name => '_')

382

query = IssueQuery.new(:project => Project.find(1), :name => '_')

372

query.add_filter('done_ratio', '<=', ['30'])

383

query.add_filter('done_ratio', '<=', ['30'])

373

assert query.statement.include?("#{Issue.table_name}.done_ratio <= 30.0")

384

assert query.statement.include?("#{Issue.table_name}.done_ratio <= 30.0")

374

find_issues_with_query(query)

385

find_issues_with_query(query)

375

end

386

end

376

387

377

def test_operator_lesser_than_on_custom_field

388

def test_operator_lesser_than_on_custom_field

378

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)

389

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)

379

query = IssueQuery.new(:project => Project.find(1), :name => '_')

390

query = IssueQuery.new(:project => Project.find(1), :name => '_')

380

query.add_filter("cf_#{f.id}", '<=', ['30'])

391

query.add_filter("cf_#{f.id}", '<=', ['30'])

381

assert_match /CAST.+ <= 30\.0/, query.statement

392

assert_match /CAST.+ <= 30\.0/, query.statement

382

find_issues_with_query(query)

393

find_issues_with_query(query)

383

end

394

end

384

395

385

def test_operator_lesser_than_on_date_custom_field

396

def test_operator_lesser_than_on_date_custom_field

386

f = IssueCustomField.create!(:name => 'filter', :field_format => 'date', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

397

f = IssueCustomField.create!(:name => 'filter', :field_format => 'date', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)

387

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '2013-04-11')

398

CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '2013-04-11')

388

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '2013-05-14')

399

CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '2013-05-14')

389

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

400

CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')

390

401

391

query = IssueQuery.new(:project => Project.find(1), :name => '_')

402

query = IssueQuery.new(:project => Project.find(1), :name => '_')

392

query.add_filter("cf_#{f.id}", '<=', ['2013-05-01'])

403

query.add_filter("cf_#{f.id}", '<=', ['2013-05-01'])

393

issue_ids = find_issues_with_query(query).map(&:id)

404

issue_ids = find_issues_with_query(query).map(&:id)

394

assert_include 1, issue_ids

405

assert_include 1, issue_ids

395

assert_not_include 2, issue_ids

406

assert_not_include 2, issue_ids

396

assert_not_include 3, issue_ids

407

assert_not_include 3, issue_ids

397

end

408

end

398

409

399

def test_operator_between

410

def test_operator_between

400

query = IssueQuery.new(:project => Project.find(1), :name => '_')

411

query = IssueQuery.new(:project => Project.find(1), :name => '_')

401

query.add_filter('done_ratio', '><', ['30', '40'])

412

query.add_filter('done_ratio', '><', ['30', '40'])

402

assert_include "#{Issue.table_name}.done_ratio BETWEEN 30.0 AND 40.0", query.statement

413

assert_include "#{Issue.table_name}.done_ratio BETWEEN 30.0 AND 40.0", query.statement

403

find_issues_with_query(query)

414

find_issues_with_query(query)

404

end

415

end

405

416

406

def test_operator_between_on_custom_field

417

def test_operator_between_on_custom_field

407

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)

418

f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)

408

query = IssueQuery.new(:project => Project.find(1), :name => '_')

419

query = IssueQuery.new(:project => Project.find(1), :name => '_')

409

query.add_filter("cf_#{f.id}", '><', ['30', '40'])

420

query.add_filter("cf_#{f.id}", '><', ['30', '40'])

410

assert_match /CAST.+ BETWEEN 30.0 AND 40.0/, query.statement

421

assert_match /CAST.+ BETWEEN 30.0 AND 40.0/, query.statement

411

find_issues_with_query(query)

422

find_issues_with_query(query)

412

end

423

end

413

424

414

def test_date_filter_should_not_accept_non_date_values

425

def test_date_filter_should_not_accept_non_date_values

415

query = IssueQuery.new(:name => '_')

426

query = IssueQuery.new(:name => '_')

416

query.add_filter('created_on', '=', ['a'])

427

query.add_filter('created_on', '=', ['a'])

417

428

418

assert query.has_filter?('created_on')

429

assert query.has_filter?('created_on')

419

assert !query.valid?

430

assert !query.valid?

420

end

431

end

421

432

422

def test_date_filter_should_not_accept_invalid_date_values

433

def test_date_filter_should_not_accept_invalid_date_values

423

query = IssueQuery.new(:name => '_')

434

query = IssueQuery.new(:name => '_')

424

query.add_filter('created_on', '=', ['2011-01-34'])

435

query.add_filter('created_on', '=', ['2011-01-34'])

425

436

426

assert query.has_filter?('created_on')

437

assert query.has_filter?('created_on')

427

assert !query.valid?

438

assert !query.valid?

428

end

439

end

429

440

430

def test_relative_date_filter_should_not_accept_non_integer_values

441

def test_relative_date_filter_should_not_accept_non_integer_values

431

query = IssueQuery.new(:name => '_')

442

query = IssueQuery.new(:name => '_')

432

query.add_filter('created_on', '>t-', ['a'])

443

query.add_filter('created_on', '>t-', ['a'])

433

444

434

assert query.has_filter?('created_on')

445

assert query.has_filter?('created_on')

435

assert !query.valid?

446

assert !query.valid?

436

end

447

end

437

448

438

def test_operator_date_equals

449

def test_operator_date_equals

439

query = IssueQuery.new(:name => '_')

450

query = IssueQuery.new(:name => '_')

440

query.add_filter('due_date', '=', ['2011-07-10'])

451

query.add_filter('due_date', '=', ['2011-07-10'])

441

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

452

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

442

find_issues_with_query(query)

453

find_issues_with_query(query)

443

end

454

end

444

455

445

def test_operator_date_lesser_than

456

def test_operator_date_lesser_than

446

query = IssueQuery.new(:name => '_')

457

query = IssueQuery.new(:name => '_')

447

query.add_filter('due_date', '<=', ['2011-07-10'])

458

query.add_filter('due_date', '<=', ['2011-07-10'])

448

assert_match /issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement

459

assert_match /issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement

449

find_issues_with_query(query)

460

find_issues_with_query(query)

450

end

461

end

451

462

452

def test_operator_date_lesser_than_with_timestamp

463

def test_operator_date_lesser_than_with_timestamp

453

query = IssueQuery.new(:name => '_')

464

query = IssueQuery.new(:name => '_')

454

query.add_filter('updated_on', '<=', ['2011-07-10T19:13:52'])

465

query.add_filter('updated_on', '<=', ['2011-07-10T19:13:52'])

455

assert_match /issues\.updated_on <= '2011-07-10 19:13:52/, query.statement

466

assert_match /issues\.updated_on <= '2011-07-10 19:13:52/, query.statement

456

find_issues_with_query(query)

467

find_issues_with_query(query)

457

end

468

end

458

469

459

def test_operator_date_greater_than

470

def test_operator_date_greater_than

460

query = IssueQuery.new(:name => '_')

471

query = IssueQuery.new(:name => '_')

461

query.add_filter('due_date', '>=', ['2011-07-10'])

472

query.add_filter('due_date', '>=', ['2011-07-10'])

462

assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?'/, query.statement

473

assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?'/, query.statement

463

find_issues_with_query(query)

474

find_issues_with_query(query)

464

end

475

end

465

476

466

def test_operator_date_greater_than_with_timestamp

477

def test_operator_date_greater_than_with_timestamp

467

query = IssueQuery.new(:name => '_')

478

query = IssueQuery.new(:name => '_')

468

query.add_filter('updated_on', '>=', ['2011-07-10T19:13:52'])

479

query.add_filter('updated_on', '>=', ['2011-07-10T19:13:52'])

469

assert_match /issues\.updated_on > '2011-07-10 19:13:51(\.0+)?'/, query.statement

480

assert_match /issues\.updated_on > '2011-07-10 19:13:51(\.0+)?'/, query.statement

470

find_issues_with_query(query)

481

find_issues_with_query(query)

471

end

482

end

472

483

473

def test_operator_date_between

484

def test_operator_date_between

474

query = IssueQuery.new(:name => '_')

485

query = IssueQuery.new(:name => '_')

475

query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])

486

query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])

476

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

487

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

477

find_issues_with_query(query)

488

find_issues_with_query(query)

478

end

489

end

479

490

480

def test_operator_in_more_than

491

def test_operator_in_more_than

481

Issue.find(7).update_attribute(:due_date, (Date.today + 15))

492

Issue.find(7).update_attribute(:due_date, (Date.today + 15))

482

query = IssueQuery.new(:project => Project.find(1), :name => '_')

493

query = IssueQuery.new(:project => Project.find(1), :name => '_')

483

query.add_filter('due_date', '>t+', ['15'])

494

query.add_filter('due_date', '>t+', ['15'])

484

issues = find_issues_with_query(query)

495

issues = find_issues_with_query(query)

485

assert !issues.empty?

496

assert !issues.empty?

486

issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}

497

issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}

487

end

498

end

488

499

489

def test_operator_in_less_than

500

def test_operator_in_less_than

490

query = IssueQuery.new(:project => Project.find(1), :name => '_')

501

query = IssueQuery.new(:project => Project.find(1), :name => '_')

491

query.add_filter('due_date', '<t+', ['15'])

502

query.add_filter('due_date', '<t+', ['15'])

492

issues = find_issues_with_query(query)

503

issues = find_issues_with_query(query)

493

assert !issues.empty?

504

assert !issues.empty?

494

issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}

505

issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}

495

end

506

end

496

507

497

def test_operator_in_the_next_days

508

def test_operator_in_the_next_days

498

query = IssueQuery.new(:project => Project.find(1), :name => '_')

509

query = IssueQuery.new(:project => Project.find(1), :name => '_')

499

query.add_filter('due_date', '><t+', ['15'])

510

query.add_filter('due_date', '><t+', ['15'])

500

issues = find_issues_with_query(query)

511

issues = find_issues_with_query(query)

501

assert !issues.empty?

512

assert !issues.empty?

502

issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}

513

issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}

503

end

514

end

504

515

505

def test_operator_less_than_ago

516

def test_operator_less_than_ago

506

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

517

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

507

query = IssueQuery.new(:project => Project.find(1), :name => '_')

518

query = IssueQuery.new(:project => Project.find(1), :name => '_')

508

query.add_filter('due_date', '>t-', ['3'])

519

query.add_filter('due_date', '>t-', ['3'])

509

issues = find_issues_with_query(query)

520

issues = find_issues_with_query(query)

510

assert !issues.empty?

521

assert !issues.empty?

511

issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}

522

issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}

512

end

523

end

513

524

514

def test_operator_in_the_past_days

525

def test_operator_in_the_past_days

515

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

526

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

516

query = IssueQuery.new(:project => Project.find(1), :name => '_')

527

query = IssueQuery.new(:project => Project.find(1), :name => '_')

517

query.add_filter('due_date', '><t-', ['3'])

528

query.add_filter('due_date', '><t-', ['3'])

518

issues = find_issues_with_query(query)

529

issues = find_issues_with_query(query)

519

assert !issues.empty?

530

assert !issues.empty?

520

issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}

531

issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}

521

end

532

end

522

533

523

def test_operator_more_than_ago

534

def test_operator_more_than_ago

524

Issue.find(7).update_attribute(:due_date, (Date.today - 10))

535

Issue.find(7).update_attribute(:due_date, (Date.today - 10))

525

query = IssueQuery.new(:project => Project.find(1), :name => '_')

536

query = IssueQuery.new(:project => Project.find(1), :name => '_')

526

query.add_filter('due_date', '<t-', ['10'])

537

query.add_filter('due_date', '<t-', ['10'])

527

assert query.statement.include?("#{Issue.table_name}.due_date <=")

538

assert query.statement.include?("#{Issue.table_name}.due_date <=")

528

issues = find_issues_with_query(query)

539

issues = find_issues_with_query(query)

529

assert !issues.empty?

540

assert !issues.empty?

530

issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}

541

issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}

531

end

542

end

532

543

533

def test_operator_in

544

def test_operator_in

534

Issue.find(7).update_attribute(:due_date, (Date.today + 2))

545

Issue.find(7).update_attribute(:due_date, (Date.today + 2))

535

query = IssueQuery.new(:project => Project.find(1), :name => '_')

546

query = IssueQuery.new(:project => Project.find(1), :name => '_')

536

query.add_filter('due_date', 't+', ['2'])

547

query.add_filter('due_date', 't+', ['2'])

537

issues = find_issues_with_query(query)

548

issues = find_issues_with_query(query)

538

assert !issues.empty?

549

assert !issues.empty?

539

issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}

550

issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}

540

end

551

end

541

552

542

def test_operator_ago

553

def test_operator_ago

543

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

554

Issue.find(7).update_attribute(:due_date, (Date.today - 3))

544

query = IssueQuery.new(:project => Project.find(1), :name => '_')

555

query = IssueQuery.new(:project => Project.find(1), :name => '_')

545

query.add_filter('due_date', 't-', ['3'])

556

query.add_filter('due_date', 't-', ['3'])

546

issues = find_issues_with_query(query)

557

issues = find_issues_with_query(query)

547

assert !issues.empty?

558

assert !issues.empty?

548

issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}

559

issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}

549

end

560

end

550

561

551

def test_operator_today

562

def test_operator_today

552

query = IssueQuery.new(:project => Project.find(1), :name => '_')

563

query = IssueQuery.new(:project => Project.find(1), :name => '_')

553

query.add_filter('due_date', 't', [''])

564

query.add_filter('due_date', 't', [''])

554

issues = find_issues_with_query(query)

565

issues = find_issues_with_query(query)

555

assert !issues.empty?

566

assert !issues.empty?

556

issues.each {|issue| assert_equal Date.today, issue.due_date}

567

issues.each {|issue| assert_equal Date.today, issue.due_date}

557

end

568

end

558

569

559

def test_operator_~~this_week_on_date~~

570

def test_operator_date_periods

560

query = IssueQuery.new(:project => Project.find(1), :name => '_')

571

%w(t ld w lw l2w m lm y).each do |operator|

561

query.add_filter('due_date', 'w', [''])

572

query = IssueQuery.new(:name => '_')

562

find_issues_with_query(query)

573

query.add_filter('due_date', operator, [''])

574

assert query.valid?

575

assert query.issues

576

end

563

end

577

end

564

578

565

def test_operator_~~this_week_on_~~datetime

579

def test_operator_datetime_periods

566

query = IssueQuery.new(:project => Project.find(1), :name => '_')

580

%w(t ld w lw l2w m lm y).each do |operator|

567

query.add_filter('created_on', 'w', [''])

581

query = IssueQuery.new(:name => '_')

568

find_issues_with_query(query)

582

query.add_filter('created_on', operator, [''])

583

assert query.valid?

584

assert query.issues

585

end

569

end

586

end

570

587

571

def test_operator_contains

588

def test_operator_contains

572

query = IssueQuery.new(:project => Project.find(1), :name => '_')

589

query = IssueQuery.new(:project => Project.find(1), :name => '_')

573

query.add_filter('subject', '~', ['uNable'])

590

query.add_filter('subject', '~', ['uNable'])

574

assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")

591

assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")

575

result = find_issues_with_query(query)

592

result = find_issues_with_query(query)

576

assert result.empty?

593

assert result.empty?

577

result.each {|issue| assert issue.subject.downcase.include?('unable') }

594

result.each {|issue| assert issue.subject.downcase.include?('unable') }

578

end

595

end

579

596

580

def test_range_for_this_week_with_week_starting_on_monday

597

def test_range_for_this_week_with_week_starting_on_monday

581

I18n.locale = :fr

598

I18n.locale = :fr

582

assert_equal '1', I18n.t(:general_first_day_of_week)

599

assert_equal '1', I18n.t(:general_first_day_of_week)

583

600

584

Date.stubs(:today).returns(Date.parse('2011-04-29'))

601

Date.stubs(:today).returns(Date.parse('2011-04-29'))

585

602

586

query = IssueQuery.new(:project => Project.find(1), :name => '_')

603

query = IssueQuery.new(:project => Project.find(1), :name => '_')

587

query.add_filter('due_date', 'w', [''])

604

query.add_filter('due_date', 'w', [''])

588

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}"

605

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}"

589

I18n.locale = :en

606

I18n.locale = :en

590

end

607

end

591

608

592

def test_range_for_this_week_with_week_starting_on_sunday

609

def test_range_for_this_week_with_week_starting_on_sunday

593

I18n.locale = :en

610

I18n.locale = :en

594

assert_equal '7', I18n.t(:general_first_day_of_week)

611

assert_equal '7', I18n.t(:general_first_day_of_week)

595

612

596

Date.stubs(:today).returns(Date.parse('2011-04-29'))

613

Date.stubs(:today).returns(Date.parse('2011-04-29'))

597

614

598

query = IssueQuery.new(:project => Project.find(1), :name => '_')

615

query = IssueQuery.new(:project => Project.find(1), :name => '_')

599

query.add_filter('due_date', 'w', [''])

616

query.add_filter('due_date', 'w', [''])

600

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}"

617

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}"

601

end

618

end

602

619

603

def test_operator_does_not_contains

620

def test_operator_does_not_contains

604

query = IssueQuery.new(:project => Project.find(1), :name => '_')

621

query = IssueQuery.new(:project => Project.find(1), :name => '_')

605

query.add_filter('subject', '!~', ['uNable'])

622

query.add_filter('subject', '!~', ['uNable'])

606

assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")

623

assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")

607

find_issues_with_query(query)

624

find_issues_with_query(query)

608

end

625

end

609

626

610

def test_filter_assigned_to_me

627

def test_filter_assigned_to_me

611

user = User.find(2)

628

user = User.find(2)

612

group = Group.find(10)

629

group = Group.find(10)

613

User.current = user

630

User.current = user

614

i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user)

631

i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user)

615

i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group)

632

i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group)

616

i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => Group.find(11))

633

i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => Group.find(11))

617

group.users << user

634

group.users << user

618

635

619

query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})

636

query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})

620

result = query.issues

637

result = query.issues

621

assert_equal Issue.visible.where(:assigned_to_id => ([2] + user.reload.group_ids)).sort_by(&:id), result.sort_by(&:id)

638

assert_equal Issue.visible.where(:assigned_to_id => ([2] + user.reload.group_ids)).sort_by(&:id), result.sort_by(&:id)

622

639

623

assert result.include?(i1)

640

assert result.include?(i1)

624

assert result.include?(i2)

641

assert result.include?(i2)

625

assert !result.include?(i3)

642

assert !result.include?(i3)

626

end

643

end

627

644

628

def test_user_custom_field_filtered_on_me

645

def test_user_custom_field_filtered_on_me

629

User.current = User.find(2)

646

User.current = User.find(2)

630

cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])

647

cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])

631

issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)

648

issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)

632

issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})

649

issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})

633

650

634

query = IssueQuery.new(:name => '_', :project => Project.find(1))

651

query = IssueQuery.new(:name => '_', :project => Project.find(1))

635

filter = query.available_filters["cf_#{cf.id}"]

652

filter = query.available_filters["cf_#{cf.id}"]

636

assert_not_nil filter

653

assert_not_nil filter

637

assert_include 'me', filter[:values].map{|v| v[1]}

654

assert_include 'me', filter[:values].map{|v| v[1]}

638

655

639

query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}

656

query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}

640

result = query.issues

657

result = query.issues

641

assert_equal 1, result.size

658

assert_equal 1, result.size

642

assert_equal issue1, result.first

659

assert_equal issue1, result.first

643

end

660

end

644

661

662

def test_filter_on_me_by_anonymous_user

663

User.current = nil

664

query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})

665

assert_equal [], query.issues

666

end

667

645

def test_filter_my_projects

668

def test_filter_my_projects

646

User.current = User.find(2)

669

User.current = User.find(2)

647

query = IssueQuery.new(:name => '_')

670

query = IssueQuery.new(:name => '_')

648

filter = query.available_filters['project_id']

671

filter = query.available_filters['project_id']

649

assert_not_nil filter

672

assert_not_nil filter

650

assert_include 'mine', filter[:values].map{|v| v[1]}

673

assert_include 'mine', filter[:values].map{|v| v[1]}

651

674

652

query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}

675

query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}

653

result = query.issues

676

result = query.issues

654

assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}

677

assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}

655

end

678

end

656

679

657

def test_filter_watched_issues

680

def test_filter_watched_issues

658

User.current = User.find(1)

681

User.current = User.find(1)

659

query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})

682

query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})

660

result = find_issues_with_query(query)

683

result = find_issues_with_query(query)

661

assert_not_nil result

684

assert_not_nil result

662

assert !result.empty?

685

assert !result.empty?

663

assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)

686

assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)

664

User.current = nil

687

User.current = nil

665

end

688

end

666

689

667

def test_filter_unwatched_issues

690

def test_filter_unwatched_issues

668

User.current = User.find(1)

691

User.current = User.find(1)

669

query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})

692

query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})

670

result = find_issues_with_query(query)

693

result = find_issues_with_query(query)

671

assert_not_nil result

694

assert_not_nil result

672

assert !result.empty?

695

assert !result.empty?

673

assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)

696

assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)

674

User.current = nil

697

User.current = nil

675

end

698

end

676

699

677

def test_filter_on_custom_field_should_ignore_projects_with_field_disabled

700

def test_filter_on_custom_field_should_ignore_projects_with_field_disabled

678

field = IssueCustomField.generate!(:trackers => Tracker.all, :project_ids => [1, 3, 4], :is_filter => true)

701

field = IssueCustomField.generate!(:trackers => Tracker.all, :project_ids => [1, 3, 4], :is_filter => true)

679

Issue.generate!(:project_id => 3, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

702

Issue.generate!(:project_id => 3, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

680

Issue.generate!(:project_id => 4, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

703

Issue.generate!(:project_id => 4, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

681

704

682

query = IssueQuery.new(:name => '_', :project => Project.find(1))

705

query = IssueQuery.new(:name => '_', :project => Project.find(1))

683

query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}

706

query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}

684

assert_equal 2, find_issues_with_query(query).size

707

assert_equal 2, find_issues_with_query(query).size

685

708

686

field.project_ids = [1, 3] # Disable the field for project 4

709

field.project_ids = [1, 3] # Disable the field for project 4

687

field.save!

710

field.save!

688

assert_equal 1, find_issues_with_query(query).size

711

assert_equal 1, find_issues_with_query(query).size

689

end

712

end

690

713

691

def test_filter_on_custom_field_should_ignore_trackers_with_field_disabled

714

def test_filter_on_custom_field_should_ignore_trackers_with_field_disabled

692

field = IssueCustomField.generate!(:tracker_ids => [1, 2], :is_for_all => true, :is_filter => true)

715

field = IssueCustomField.generate!(:tracker_ids => [1, 2], :is_for_all => true, :is_filter => true)

693

Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => 'Foo'})

716

Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => 'Foo'})

694

Issue.generate!(:project_id => 1, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

717

Issue.generate!(:project_id => 1, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})

695

718

696

query = IssueQuery.new(:name => '_', :project => Project.find(1))

719

query = IssueQuery.new(:name => '_', :project => Project.find(1))

697

query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}

720

query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}

698

assert_equal 2, find_issues_with_query(query).size

721

assert_equal 2, find_issues_with_query(query).size

699

722

700

field.tracker_ids = [1] # Disable the field for tracker 2

723

field.tracker_ids = [1] # Disable the field for tracker 2

701

field.save!

724

field.save!

702

assert_equal 1, find_issues_with_query(query).size

725

assert_equal 1, find_issues_with_query(query).size

703

end

726

end

704

727

705

def test_filter_on_project_custom_field

728

def test_filter_on_project_custom_field

706

field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

729

field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

707

CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo')

730

CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo')

708

CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo')

731

CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo')

709

732

710

query = IssueQuery.new(:name => '_')

733

query = IssueQuery.new(:name => '_')

711

filter_name = "project.cf_#{field.id}"

734

filter_name = "project.cf_#{field.id}"

712

assert_include filter_name, query.available_filters.keys

735

assert_include filter_name, query.available_filters.keys

713

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

736

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

714

assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort

737

assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort

715

end

738

end

716

739

717

def test_filter_on_author_custom_field

740

def test_filter_on_author_custom_field

718

field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

741

field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

719

CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')

742

CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')

720

743

721

query = IssueQuery.new(:name => '_')

744

query = IssueQuery.new(:name => '_')

722

filter_name = "author.cf_#{field.id}"

745

filter_name = "author.cf_#{field.id}"

723

assert_include filter_name, query.available_filters.keys

746

assert_include filter_name, query.available_filters.keys

724

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

747

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

725

assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort

748

assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort

726

end

749

end

727

750

728

def test_filter_on_assigned_to_custom_field

751

def test_filter_on_assigned_to_custom_field

729

field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

752

field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

730

CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')

753

CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')

731

754

732

query = IssueQuery.new(:name => '_')

755

query = IssueQuery.new(:name => '_')

733

filter_name = "assigned_to.cf_#{field.id}"

756

filter_name = "assigned_to.cf_#{field.id}"

734

assert_include filter_name, query.available_filters.keys

757

assert_include filter_name, query.available_filters.keys

735

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

758

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

736

assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort

759

assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort

737

end

760

end

738

761

739

def test_filter_on_fixed_version_custom_field

762

def test_filter_on_fixed_version_custom_field

740

field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

763

field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')

741

CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo')

764

CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo')

742

765

743

query = IssueQuery.new(:name => '_')

766

query = IssueQuery.new(:name => '_')

744

filter_name = "fixed_version.cf_#{field.id}"

767

filter_name = "fixed_version.cf_#{field.id}"

745

assert_include filter_name, query.available_filters.keys

768

assert_include filter_name, query.available_filters.keys

746

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

769

query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}

747

assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort

770

assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort

748

end

771

end

749

772

750

def test_filter_on_relations_with_a_specific_issue

773

def test_filter_on_relations_with_a_specific_issue

751

IssueRelation.delete_all

774

IssueRelation.delete_all

752

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

775

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

753

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

776

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

754

777

755

query = IssueQuery.new(:name => '_')

778

query = IssueQuery.new(:name => '_')

756

query.filters = {"relates" => {:operator => '=', :values => ['1']}}

779

query.filters = {"relates" => {:operator => '=', :values => ['1']}}

757

assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort

780

assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort

758

781

759

query = IssueQuery.new(:name => '_')

782

query = IssueQuery.new(:name => '_')

760

query.filters = {"relates" => {:operator => '=', :values => ['2']}}

783

query.filters = {"relates" => {:operator => '=', :values => ['2']}}

761

assert_equal [1], find_issues_with_query(query).map(&:id).sort

784

assert_equal [1], find_issues_with_query(query).map(&:id).sort

762

end

785

end

763

786

764

def test_filter_on_relations_with_any_issues_in_a_project

787

def test_filter_on_relations_with_any_issues_in_a_project

765

IssueRelation.delete_all

788

IssueRelation.delete_all

766

with_settings :cross_project_issue_relations => '1' do

789

with_settings :cross_project_issue_relations => '1' do

767

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

790

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

768

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)

791

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)

769

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)

792

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)

770

end

793

end

771

794

772

query = IssueQuery.new(:name => '_')

795

query = IssueQuery.new(:name => '_')

773

query.filters = {"relates" => {:operator => '=p', :values => ['2']}}

796

query.filters = {"relates" => {:operator => '=p', :values => ['2']}}

774

assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort

797

assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort

775

798

776

query = IssueQuery.new(:name => '_')

799

query = IssueQuery.new(:name => '_')

777

query.filters = {"relates" => {:operator => '=p', :values => ['3']}}

800

query.filters = {"relates" => {:operator => '=p', :values => ['3']}}

778

assert_equal [1], find_issues_with_query(query).map(&:id).sort

801

assert_equal [1], find_issues_with_query(query).map(&:id).sort

779

802

780

query = IssueQuery.new(:name => '_')

803

query = IssueQuery.new(:name => '_')

781

query.filters = {"relates" => {:operator => '=p', :values => ['4']}}

804

query.filters = {"relates" => {:operator => '=p', :values => ['4']}}

782

assert_equal [], find_issues_with_query(query).map(&:id).sort

805

assert_equal [], find_issues_with_query(query).map(&:id).sort

783

end

806

end

784

807

785

def test_filter_on_relations_with_any_issues_not_in_a_project

808

def test_filter_on_relations_with_any_issues_not_in_a_project

786

IssueRelation.delete_all

809

IssueRelation.delete_all

787

with_settings :cross_project_issue_relations => '1' do

810

with_settings :cross_project_issue_relations => '1' do

788

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

811

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

789

#IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)

812

#IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)

790

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)

813

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)

791

end

814

end

792

815

793

query = IssueQuery.new(:name => '_')

816

query = IssueQuery.new(:name => '_')

794

query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}

817

query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}

795

assert_equal [1], find_issues_with_query(query).map(&:id).sort

818

assert_equal [1], find_issues_with_query(query).map(&:id).sort

796

end

819

end

797

820

798

def test_filter_on_relations_with_no_issues_in_a_project

821

def test_filter_on_relations_with_no_issues_in_a_project

799

IssueRelation.delete_all

822

IssueRelation.delete_all

800

with_settings :cross_project_issue_relations => '1' do

823

with_settings :cross_project_issue_relations => '1' do

801

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

824

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)

802

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first)

825

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first)

803

IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3))

826

IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3))

804

end

827

end

805

828

806

query = IssueQuery.new(:name => '_')

829

query = IssueQuery.new(:name => '_')

807

query.filters = {"relates" => {:operator => '!p', :values => ['2']}}

830

query.filters = {"relates" => {:operator => '!p', :values => ['2']}}

808

ids = find_issues_with_query(query).map(&:id).sort

831

ids = find_issues_with_query(query).map(&:id).sort

809

assert_include 2, ids

832

assert_include 2, ids

810

assert_not_include 1, ids

833

assert_not_include 1, ids

811

assert_not_include 3, ids

834

assert_not_include 3, ids

812

end

835

end

813

836

814

def test_filter_on_relations_with_no_issues

837

def test_filter_on_relations_with_no_issues

815

IssueRelation.delete_all

838

IssueRelation.delete_all

816

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

839

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

817

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

840

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

818

841

819

query = IssueQuery.new(:name => '_')

842

query = IssueQuery.new(:name => '_')

820

query.filters = {"relates" => {:operator => '!*', :values => ['']}}

843

query.filters = {"relates" => {:operator => '!*', :values => ['']}}

821

ids = find_issues_with_query(query).map(&:id)

844

ids = find_issues_with_query(query).map(&:id)

822

assert_equal [], ids & [1, 2, 3]

845

assert_equal [], ids & [1, 2, 3]

823

assert_include 4, ids

846

assert_include 4, ids

824

end

847

end

825

848

826

def test_filter_on_relations_with_any_issues

849

def test_filter_on_relations_with_any_issues

827

IssueRelation.delete_all

850

IssueRelation.delete_all

828

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

851

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))

829

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

852

IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))

830

853

831

query = IssueQuery.new(:name => '_')

854

query = IssueQuery.new(:name => '_')

832

query.filters = {"relates" => {:operator => '*', :values => ['']}}

855

query.filters = {"relates" => {:operator => '*', :values => ['']}}

833

assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort

856

assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort

834

end

857

end

835

858

836

def test_filter_on_relations_should_not_ignore_other_filter

859

def test_filter_on_relations_should_not_ignore_other_filter

837

issue = Issue.generate!

860

issue = Issue.generate!

838

issue1 = Issue.generate!(:status_id => 1)

861

issue1 = Issue.generate!(:status_id => 1)

839

issue2 = Issue.generate!(:status_id => 2)

862

issue2 = Issue.generate!(:status_id => 2)

840

IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue1)

863

IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue1)

841

IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue2)

864

IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue2)

842

865

843

query = IssueQuery.new(:name => '_')

866

query = IssueQuery.new(:name => '_')

844

query.filters = {

867

query.filters = {

845

"status_id" => {:operator => '=', :values => ['1']},

868

"status_id" => {:operator => '=', :values => ['1']},

846

"relates" => {:operator => '=', :values => [issue.id.to_s]}

869

"relates" => {:operator => '=', :values => [issue.id.to_s]}

847

}

870

}

848

assert_equal [issue1], find_issues_with_query(query)

871

assert_equal [issue1], find_issues_with_query(query)

849

end

872

end

850

873

851

def test_statement_should_be_nil_with_no_filters

874

def test_statement_should_be_nil_with_no_filters

852

q = IssueQuery.new(:name => '_')

875

q = IssueQuery.new(:name => '_')

853

q.filters = {}

876

q.filters = {}

854

877

855

assert q.valid?

878

assert q.valid?

856

assert_nil q.statement

879

assert_nil q.statement

857

end

880

end

858

881

859

def test_default_columns

882

def test_default_columns

860

q = IssueQuery.new

883

q = IssueQuery.new

861

assert q.columns.any?

884

assert q.columns.any?

862

assert q.inline_columns.any?

885

assert q.inline_columns.any?

863

assert q.block_columns.empty?

886

assert q.block_columns.empty?

864

end

887

end

865

888

866

def test_set_column_names

889

def test_set_column_names

867

q = IssueQuery.new

890

q = IssueQuery.new

868

q.column_names = ['tracker', :subject, '', 'unknonw_column']

891

q.column_names = ['tracker', :subject, '', 'unknonw_column']

869

assert_equal [:id, :tracker, :subject], q.columns.collect {|c| c.name}

892

assert_equal [:id, :tracker, :subject], q.columns.collect {|c| c.name}

870

end

893

end

871

894

872

def test_has_column_should_accept_a_column_name

895

def test_has_column_should_accept_a_column_name

873

q = IssueQuery.new

896

q = IssueQuery.new

874

q.column_names = ['tracker', :subject]

897

q.column_names = ['tracker', :subject]

875

assert q.has_column?(:tracker)

898

assert q.has_column?(:tracker)

876

assert !q.has_column?(:category)

899

assert !q.has_column?(:category)

877

end

900

end

878

901

879

def test_has_column_should_accept_a_column

902

def test_has_column_should_accept_a_column

880

q = IssueQuery.new

903

q = IssueQuery.new

881

q.column_names = ['tracker', :subject]

904

q.column_names = ['tracker', :subject]

882

905

883

tracker_column = q.available_columns.detect {|c| c.name==:tracker}

906

tracker_column = q.available_columns.detect {|c| c.name==:tracker}

884

assert_kind_of QueryColumn, tracker_column

907

assert_kind_of QueryColumn, tracker_column

885

category_column = q.available_columns.detect {|c| c.name==:category}

908

category_column = q.available_columns.detect {|c| c.name==:category}

886

assert_kind_of QueryColumn, category_column

909

assert_kind_of QueryColumn, category_column

887

910

888

assert q.has_column?(tracker_column)

911

assert q.has_column?(tracker_column)

889

assert !q.has_column?(category_column)

912

assert !q.has_column?(category_column)

890

end

913

end

891

914

892

def test_inline_and_block_columns

915

def test_inline_and_block_columns

893

q = IssueQuery.new

916

q = IssueQuery.new

894

q.column_names = ['subject', 'description', 'tracker']

917

q.column_names = ['subject', 'description', 'tracker']

895

918

896

assert_equal [:id, :subject, :tracker], q.inline_columns.map(&:name)

919

assert_equal [:id, :subject, :tracker], q.inline_columns.map(&:name)

897

assert_equal [:description], q.block_columns.map(&:name)

920

assert_equal [:description], q.block_columns.map(&:name)

898

end

921

end

899

922

900

def test_custom_field_columns_should_be_inline

923

def test_custom_field_columns_should_be_inline

901

q = IssueQuery.new

924

q = IssueQuery.new

902

columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}

925

columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}

903

assert columns.any?

926

assert columns.any?

904

assert_nil columns.detect {|column| !column.inline?}

927

assert_nil columns.detect {|column| !column.inline?}

905

end

928

end

906

929

907

def test_query_should_preload_spent_hours

930

def test_query_should_preload_spent_hours

908

q = IssueQuery.new(:name => '_', :column_names => [:subject, :spent_hours])

931

q = IssueQuery.new(:name => '_', :column_names => [:subject, :spent_hours])

909

assert q.has_column?(:spent_hours)

932

assert q.has_column?(:spent_hours)

910

issues = q.issues

933

issues = q.issues

911

assert_not_nil issues.first.instance_variable_get("@spent_hours")

934

assert_not_nil issues.first.instance_variable_get("@spent_hours")

912

end

935

end

913

936

914

def test_groupable_columns_should_include_custom_fields

937

def test_groupable_columns_should_include_custom_fields

915

q = IssueQuery.new

938

q = IssueQuery.new

916

column = q.groupable_columns.detect {|c| c.name == :cf_1}

939

column = q.groupable_columns.detect {|c| c.name == :cf_1}

917

assert_not_nil column

940

assert_not_nil column

918

assert_kind_of QueryCustomFieldColumn, column

941

assert_kind_of QueryCustomFieldColumn, column

919

end

942

end

920

943

921

def test_groupable_columns_should_not_include_multi_custom_fields

944

def test_groupable_columns_should_not_include_multi_custom_fields

922

field = CustomField.find(1)

945

field = CustomField.find(1)

923

field.update_attribute :multiple, true

946

field.update_attribute :multiple, true

924

947

925

q = IssueQuery.new

948

q = IssueQuery.new

926

column = q.groupable_columns.detect {|c| c.name == :cf_1}

949

column = q.groupable_columns.detect {|c| c.name == :cf_1}

927

assert_nil column

950

assert_nil column

928

end

951

end

929

952

930

def test_groupable_columns_should_include_user_custom_fields

953

def test_groupable_columns_should_include_user_custom_fields

931

cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user')

954

cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user')

932

955

933

q = IssueQuery.new

956

q = IssueQuery.new

934

assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}

957

assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}

935

end

958

end

936

959

937

def test_groupable_columns_should_include_version_custom_fields

960

def test_groupable_columns_should_include_version_custom_fields

938

cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version')

961

cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version')

939

962

940

q = IssueQuery.new

963

q = IssueQuery.new

941

assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}

964

assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}

942

end

965

end

943

966

944

def test_grouped_with_valid_column

967

def test_grouped_with_valid_column

945

q = IssueQuery.new(:group_by => 'status')

968

q = IssueQuery.new(:group_by => 'status')

946

assert q.grouped?

969

assert q.grouped?

947

assert_not_nil q.group_by_column

970

assert_not_nil q.group_by_column

948

assert_equal :status, q.group_by_column.name

971

assert_equal :status, q.group_by_column.name

949

assert_not_nil q.group_by_statement

972

assert_not_nil q.group_by_statement

950

assert_equal 'status', q.group_by_statement

973

assert_equal 'status', q.group_by_statement

951

end

974

end

952

975

953

def test_grouped_with_invalid_column

976

def test_grouped_with_invalid_column

954

q = IssueQuery.new(:group_by => 'foo')

977

q = IssueQuery.new(:group_by => 'foo')

955

assert !q.grouped?

978

assert !q.grouped?

956

assert_nil q.group_by_column

979

assert_nil q.group_by_column

957

assert_nil q.group_by_statement

980

assert_nil q.group_by_statement

958

end

981

end

959

982

960

def test_sortable_columns_should_sort_assignees_according_to_user_format_setting

983

def test_sortable_columns_should_sort_assignees_according_to_user_format_setting

961

with_settings :user_format => 'lastname_coma_firstname' do

984

with_settings :user_format => 'lastname_coma_firstname' do

962

q = IssueQuery.new

985

q = IssueQuery.new

963

assert q.sortable_columns.has_key?('assigned_to')

986

assert q.sortable_columns.has_key?('assigned_to')

964

assert_equal %w(users.lastname users.firstname users.id), q.sortable_columns['assigned_to']

987

assert_equal %w(users.lastname users.firstname users.id), q.sortable_columns['assigned_to']

965

end

988

end

966

end

989

end

967

990

968

def test_sortable_columns_should_sort_authors_according_to_user_format_setting

991

def test_sortable_columns_should_sort_authors_according_to_user_format_setting

969

with_settings :user_format => 'lastname_coma_firstname' do

992

with_settings :user_format => 'lastname_coma_firstname' do

970

q = IssueQuery.new

993

q = IssueQuery.new

971

assert q.sortable_columns.has_key?('author')

994

assert q.sortable_columns.has_key?('author')

972

assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author']

995

assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author']

973

end

996

end

974

end

997

end

975

998

976

def test_sortable_columns_should_include_custom_field

999

def test_sortable_columns_should_include_custom_field

977

q = IssueQuery.new

1000

q = IssueQuery.new

978

assert q.sortable_columns['cf_1']

1001

assert q.sortable_columns['cf_1']

979

end

1002

end

980

1003

981

def test_sortable_columns_should_not_include_multi_custom_field

1004

def test_sortable_columns_should_not_include_multi_custom_field

982

field = CustomField.find(1)

1005

field = CustomField.find(1)

983

field.update_attribute :multiple, true

1006

field.update_attribute :multiple, true

984

1007

985

q = IssueQuery.new

1008

q = IssueQuery.new

986

assert !q.sortable_columns['cf_1']

1009

assert !q.sortable_columns['cf_1']

987

end

1010

end

988

1011

989

def test_default_sort

1012

def test_default_sort

990

q = IssueQuery.new

1013

q = IssueQuery.new

991

assert_equal [], q.sort_criteria

1014

assert_equal [], q.sort_criteria

992

end

1015

end

993

1016

994

def test_set_sort_criteria_with_hash

1017

def test_set_sort_criteria_with_hash

995

q = IssueQuery.new

1018

q = IssueQuery.new

996

q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}

1019

q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}

997

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

1020

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

998

end

1021

end

999

1022

1000

def test_set_sort_criteria_with_array

1023

def test_set_sort_criteria_with_array

1001

q = IssueQuery.new

1024

q = IssueQuery.new

1002

q.sort_criteria = [['priority', 'desc'], 'tracker']

1025

q.sort_criteria = [['priority', 'desc'], 'tracker']

1003

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

1026

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

1004

end

1027

end

1005

1028

1006

def test_create_query_with_sort

1029

def test_create_query_with_sort

1007

q = IssueQuery.new(:name => 'Sorted')

1030

q = IssueQuery.new(:name => 'Sorted')

1008

q.sort_criteria = [['priority', 'desc'], 'tracker']

1031

q.sort_criteria = [['priority', 'desc'], 'tracker']

1009

assert q.save

1032

assert q.save

1010

q.reload

1033

q.reload

1011

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

1034

assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria

1012

end

1035

end

1013

1036

1014

def test_sort_by_string_custom_field_asc

1037

def test_sort_by_string_custom_field_asc

1015

q = IssueQuery.new

1038

q = IssueQuery.new

1016

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

1039

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

1017

assert c

1040

assert c

1018

assert c.sortable

1041

assert c.sortable

1019

issues = q.issues(:order => "#{c.sortable} ASC")

1042

issues = q.issues(:order => "#{c.sortable} ASC")

1020

values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

1043

values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

1021

assert !values.empty?

1044

assert !values.empty?

1022

assert_equal values.sort, values

1045

assert_equal values.sort, values

1023

end

1046

end

1024

1047

1025

def test_sort_by_string_custom_field_desc

1048

def test_sort_by_string_custom_field_desc

1026

q = IssueQuery.new

1049

q = IssueQuery.new

1027

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

1050

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }

1028

assert c

1051

assert c

1029

assert c.sortable

1052

assert c.sortable

1030

issues = q.issues(:order => "#{c.sortable} DESC")

1053

issues = q.issues(:order => "#{c.sortable} DESC")

1031

values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

1054

values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}

1032

assert !values.empty?

1055

assert !values.empty?

1033

assert_equal values.sort.reverse, values

1056

assert_equal values.sort.reverse, values

1034

end

1057

end

1035

1058

1036

def test_sort_by_float_custom_field_asc

1059

def test_sort_by_float_custom_field_asc

1037

q = IssueQuery.new

1060

q = IssueQuery.new

1038

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }

1061

c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }

1039

assert c

1062

assert c

1040

assert c.sortable

1063

assert c.sortable

1041

issues = q.issues(:order => "#{c.sortable} ASC")

1064

issues = q.issues(:order => "#{c.sortable} ASC")

1042

values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact

1065

values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact

1043

assert !values.empty?

1066

assert !values.empty?

1044

assert_equal values.sort, values

1067

assert_equal values.sort, values

1045

end

1068

end

1046

1069

1047

def test_invalid_query_should_raise_query_statement_invalid_error

1070

def test_invalid_query_should_raise_query_statement_invalid_error

1048

q = IssueQuery.new

1071

q = IssueQuery.new

1049

assert_raise Query::StatementInvalid do

1072

assert_raise Query::StatementInvalid do

1050

q.issues(:conditions => "foo = 1")

1073

q.issues(:conditions => "foo = 1")

1051

end

1074

end

1052

end

1075

end

1053

1076

1054

def test_issue_count

1077

def test_issue_count

1055

q = IssueQuery.new(:name => '_')

1078

q = IssueQuery.new(:name => '_')

1056

issue_count = q.issue_count

1079

issue_count = q.issue_count

1057

assert_equal q.issues.size, issue_count

1080

assert_equal q.issues.size, issue_count

1058

end

1081

end

1059

1082

1060

def test_issue_count_with_archived_issues

1083

def test_issue_count_with_archived_issues

1061

p = Project.generate! do |project|

1084

p = Project.generate! do |project|

1062

project.status = Project::STATUS_ARCHIVED

1085

project.status = Project::STATUS_ARCHIVED

1063

end

1086

end

1064

i = Issue.generate!( :project => p, :tracker => p.trackers.first )

1087

i = Issue.generate!( :project => p, :tracker => p.trackers.first )

1065

assert !i.visible?

1088

assert !i.visible?

1066

1089

1067

test_issue_count

1090

test_issue_count

1068

end

1091

end

1069

1092

1070

def test_issue_count_by_association_group

1093

def test_issue_count_by_association_group

1071

q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')

1094

q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')

1072

count_by_group = q.issue_count_by_group

1095

count_by_group = q.issue_count_by_group

1073

assert_kind_of Hash, count_by_group

1096

assert_kind_of Hash, count_by_group

1074

assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1097

assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1075

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1098

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1076

assert count_by_group.has_key?(User.find(3))

1099

assert count_by_group.has_key?(User.find(3))

1077

end

1100

end

1078

1101

1079

def test_issue_count_by_list_custom_field_group

1102

def test_issue_count_by_list_custom_field_group

1080

q = IssueQuery.new(:name => '_', :group_by => 'cf_1')

1103

q = IssueQuery.new(:name => '_', :group_by => 'cf_1')

1081

count_by_group = q.issue_count_by_group

1104

count_by_group = q.issue_count_by_group

1082

assert_kind_of Hash, count_by_group

1105

assert_kind_of Hash, count_by_group

1083

assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1106

assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1084

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1107

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1085

assert count_by_group.has_key?('MySQL')

1108

assert count_by_group.has_key?('MySQL')

1086

end

1109

end

1087

1110

1088

def test_issue_count_by_date_custom_field_group

1111

def test_issue_count_by_date_custom_field_group

1089

q = IssueQuery.new(:name => '_', :group_by => 'cf_8')

1112

q = IssueQuery.new(:name => '_', :group_by => 'cf_8')

1090

count_by_group = q.issue_count_by_group

1113

count_by_group = q.issue_count_by_group

1091

assert_kind_of Hash, count_by_group

1114

assert_kind_of Hash, count_by_group

1092

assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1115

assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort

1093

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1116

assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq

1094

end

1117

end

1095

1118

1096

def test_issue_count_with_nil_group_only

1119

def test_issue_count_with_nil_group_only

1097

Issue.update_all("assigned_to_id = NULL")

1120

Issue.update_all("assigned_to_id = NULL")

1098

1121

1099

q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')

1122

q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')

1100

count_by_group = q.issue_count_by_group

1123

count_by_group = q.issue_count_by_group

1101

assert_kind_of Hash, count_by_group

1124

assert_kind_of Hash, count_by_group

1102

assert_equal 1, count_by_group.keys.size

1125

assert_equal 1, count_by_group.keys.size

1103

assert_nil count_by_group.keys.first

1126

assert_nil count_by_group.keys.first

1104

end

1127

end

1105

1128

1106

def test_issue_ids

1129

def test_issue_ids

1107

q = IssueQuery.new(:name => '_')

1130

q = IssueQuery.new(:name => '_')

1108

order = "issues.subject, issues.id"

1131

order = "issues.subject, issues.id"

1109

issues = q.issues(:order => order)

1132

issues = q.issues(:order => order)

1110

assert_equal issues.map(&:id), q.issue_ids(:order => order)

1133

assert_equal issues.map(&:id), q.issue_ids(:order => order)

1111

end

1134

end

1112

1135

1113

def test_label_for

1136

def test_label_for

1114

set_language_if_valid 'en'

1137

set_language_if_valid 'en'

1115

q = IssueQuery.new

1138

q = IssueQuery.new

1116

assert_equal 'Assignee', q.label_for('assigned_to_id')

1139

assert_equal 'Assignee', q.label_for('assigned_to_id')

1117

end

1140

end

1118

1141

1119

def test_label_for_fr

1142

def test_label_for_fr

1120

set_language_if_valid 'fr'

1143

set_language_if_valid 'fr'

1121

q = IssueQuery.new

1144

q = IssueQuery.new

1122

assert_equal "Assign\xc3\xa9 \xc3\xa0".force_encoding('UTF-8'), q.label_for('assigned_to_id')

1145

assert_equal "Assign\xc3\xa9 \xc3\xa0".force_encoding('UTF-8'), q.label_for('assigned_to_id')

1123

end

1146

end

1124

1147

1125

def test_editable_by

1148

def test_editable_by

1126

admin = User.find(1)

1149

admin = User.find(1)

1127

manager = User.find(2)

1150

manager = User.find(2)

1128

developer = User.find(3)

1151

developer = User.find(3)

1129

1152

1130

# Public query on project 1

1153

# Public query on project 1

1131

q = IssueQuery.find(1)

1154

q = IssueQuery.find(1)

1132

assert q.editable_by?(admin)

1155

assert q.editable_by?(admin)

1133

assert q.editable_by?(manager)

1156

assert q.editable_by?(manager)

1134

assert !q.editable_by?(developer)

1157

assert !q.editable_by?(developer)

1135

1158

1136

# Private query on project 1

1159

# Private query on project 1

1137

q = IssueQuery.find(2)

1160

q = IssueQuery.find(2)

1138

assert q.editable_by?(admin)

1161

assert q.editable_by?(admin)

1139

assert !q.editable_by?(manager)

1162

assert !q.editable_by?(manager)

1140

assert q.editable_by?(developer)

1163

assert q.editable_by?(developer)

1141

1164

1142

# Private query for all projects

1165

# Private query for all projects

1143

q = IssueQuery.find(3)

1166

q = IssueQuery.find(3)

1144

assert q.editable_by?(admin)

1167

assert q.editable_by?(admin)

1145

assert !q.editable_by?(manager)

1168

assert !q.editable_by?(manager)

1146

assert q.editable_by?(developer)

1169

assert q.editable_by?(developer)

1147

1170

1148

# Public query for all projects

1171

# Public query for all projects

1149

q = IssueQuery.find(4)

1172

q = IssueQuery.find(4)

1150

assert q.editable_by?(admin)

1173

assert q.editable_by?(admin)

1151

assert !q.editable_by?(manager)

1174

assert !q.editable_by?(manager)

1152

assert !q.editable_by?(developer)

1175

assert !q.editable_by?(developer)

1153

end

1176

end

1154

1177

1155

def test_visible_scope

1178

def test_visible_scope

1156

query_ids = IssueQuery.visible(User.anonymous).map(&:id)

1179

query_ids = IssueQuery.visible(User.anonymous).map(&:id)

1157

1180

1158

assert query_ids.include?(1), 'public query on public project was not visible'

1181

assert query_ids.include?(1), 'public query on public project was not visible'

1159

assert query_ids.include?(4), 'public query for all projects was not visible'

1182

assert query_ids.include?(4), 'public query for all projects was not visible'

1160

assert !query_ids.include?(2), 'private query on public project was visible'

1183

assert !query_ids.include?(2), 'private query on public project was visible'

1161

assert !query_ids.include?(3), 'private query for all projects was visible'

1184

assert !query_ids.include?(3), 'private query for all projects was visible'

1162

assert !query_ids.include?(7), 'public query on private project was visible'

1185

assert !query_ids.include?(7), 'public query on private project was visible'

1163

end

1186

end

1164

1187

1165

def test_query_with_public_visibility_should_be_visible_to_anyone

1188

def test_query_with_public_visibility_should_be_visible_to_anyone

1166

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)

1189

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)

1167

1190

1168

assert q.visible?(User.anonymous)

1191

assert q.visible?(User.anonymous)

1169

assert IssueQuery.visible(User.anonymous).find_by_id(q.id)

1192

assert IssueQuery.visible(User.anonymous).find_by_id(q.id)

1170

1193

1171

assert q.visible?(User.find(7))

1194

assert q.visible?(User.find(7))

1172

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1195

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1173

1196

1174

assert q.visible?(User.find(2))

1197

assert q.visible?(User.find(2))

1175

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1198

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1176

1199

1177

assert q.visible?(User.find(1))

1200

assert q.visible?(User.find(1))

1178

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1201

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1179

end

1202

end

1180

1203

1181

def test_query_with_roles_visibility_should_be_visible_to_user_with_role

1204

def test_query_with_roles_visibility_should_be_visible_to_user_with_role

1182

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1,2])

1205

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1,2])

1183

1206

1184

assert !q.visible?(User.anonymous)

1207

assert !q.visible?(User.anonymous)

1185

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1208

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1186

1209

1187

assert !q.visible?(User.find(7))

1210

assert !q.visible?(User.find(7))

1188

assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)

1211

assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)

1189

1212

1190

assert q.visible?(User.find(2))

1213

assert q.visible?(User.find(2))

1191

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1214

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1192

1215

1193

assert q.visible?(User.find(1))

1216

assert q.visible?(User.find(1))

1194

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1217

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1195

end

1218

end

1196

1219

1197

def test_query_with_private_visibility_should_be_visible_to_owner

1220

def test_query_with_private_visibility_should_be_visible_to_owner

1198

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PRIVATE, :user => User.find(7))

1221

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PRIVATE, :user => User.find(7))

1199

1222

1200

assert !q.visible?(User.anonymous)

1223

assert !q.visible?(User.anonymous)

1201

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1224

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1202

1225

1203

assert q.visible?(User.find(7))

1226

assert q.visible?(User.find(7))

1204

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1227

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1205

1228

1206

assert !q.visible?(User.find(2))

1229

assert !q.visible?(User.find(2))

1207

assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)

1230

assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)

1208

1231

1209

assert q.visible?(User.find(1))

1232

assert q.visible?(User.find(1))

1210

assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)

1233

assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)

1211

end

1234

end

1212

1235

1213

test "#available_filters should include users of visible projects in cross-project view" do

1236

test "#available_filters should include users of visible projects in cross-project view" do

1214

users = IssueQuery.new.available_filters["assigned_to_id"]

1237

users = IssueQuery.new.available_filters["assigned_to_id"]

1215

assert_not_nil users

1238

assert_not_nil users

1216

assert users[:values].map{|u|u[1]}.include?("3")

1239

assert users[:values].map{|u|u[1]}.include?("3")

1217

end

1240

end

1218

1241

1219

test "#available_filters should include users of subprojects" do

1242

test "#available_filters should include users of subprojects" do

1220

user1 = User.generate!

1243

user1 = User.generate!

1221

user2 = User.generate!

1244

user2 = User.generate!

1222

project = Project.find(1)

1245

project = Project.find(1)

1223

Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])

1246

Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])

1224

1247

1225

users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]

1248

users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]

1226

assert_not_nil users

1249

assert_not_nil users

1227

assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)

1250

assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)

1228

assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)

1251

assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)

1229

end

1252

end

1230

1253

1231

test "#available_filters should include visible projects in cross-project view" do

1254

test "#available_filters should include visible projects in cross-project view" do

1232

projects = IssueQuery.new.available_filters["project_id"]

1255

projects = IssueQuery.new.available_filters["project_id"]

1233

assert_not_nil projects

1256

assert_not_nil projects

1234

assert projects[:values].map{|u|u[1]}.include?("1")

1257

assert projects[:values].map{|u|u[1]}.include?("1")

1235

end

1258

end

1236

1259

1237

test "#available_filters should include 'member_of_group' filter" do

1260

test "#available_filters should include 'member_of_group' filter" do

1238

query = IssueQuery.new

1261

query = IssueQuery.new

1239

assert query.available_filters.keys.include?("member_of_group")

1262

assert query.available_filters.keys.include?("member_of_group")

1240

assert_equal :list_optional, query.available_filters["member_of_group"][:type]

1263

assert_equal :list_optional, query.available_filters["member_of_group"][:type]

1241

assert query.available_filters["member_of_group"][:values].present?

1264

assert query.available_filters["member_of_group"][:values].present?

1242

assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},

1265

assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},

1243

query.available_filters["member_of_group"][:values].sort

1266

query.available_filters["member_of_group"][:values].sort

1244

end

1267

end

1245

1268

1246

test "#available_filters should include 'assigned_to_role' filter" do

1269

test "#available_filters should include 'assigned_to_role' filter" do

1247

query = IssueQuery.new

1270

query = IssueQuery.new

1248

assert query.available_filters.keys.include?("assigned_to_role")

1271

assert query.available_filters.keys.include?("assigned_to_role")

1249

assert_equal :list_optional, query.available_filters["assigned_to_role"][:type]

1272

assert_equal :list_optional, query.available_filters["assigned_to_role"][:type]

1250

1273

1251

assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])

1274

assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])

1252

assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])

1275

assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])

1253

assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])

1276

assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])

1254

1277

1255

assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])

1278

assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])

1256

assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])

1279

assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])

1257

end

1280

end

1258

1281

1259

def test_available_filters_should_include_custom_field_according_to_user_visibility

1282

def test_available_filters_should_include_custom_field_according_to_user_visibility

1260

visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)

1283

visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)

1261

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1284

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1262

1285

1263

with_current_user User.find(3) do

1286

with_current_user User.find(3) do

1264

query = IssueQuery.new

1287

query = IssueQuery.new

1265

assert_include "cf_#{visible_field.id}", query.available_filters.keys

1288

assert_include "cf_#{visible_field.id}", query.available_filters.keys

1266

assert_not_include "cf_#{hidden_field.id}", query.available_filters.keys

1289

assert_not_include "cf_#{hidden_field.id}", query.available_filters.keys

1267

end

1290

end

1268

end

1291

end

1269

1292

1270

def test_available_columns_should_include_custom_field_according_to_user_visibility

1293

def test_available_columns_should_include_custom_field_according_to_user_visibility

1271

visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)

1294

visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)

1272

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1295

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1273

1296

1274

with_current_user User.find(3) do

1297

with_current_user User.find(3) do

1275

query = IssueQuery.new

1298

query = IssueQuery.new

1276

assert_include :"cf_#{visible_field.id}", query.available_columns.map(&:name)

1299

assert_include :"cf_#{visible_field.id}", query.available_columns.map(&:name)

1277

assert_not_include :"cf_#{hidden_field.id}", query.available_columns.map(&:name)

1300

assert_not_include :"cf_#{hidden_field.id}", query.available_columns.map(&:name)

1278

end

1301

end

1279

end

1302

end

1280

1303

1281

def setup_member_of_group

1304

def setup_member_of_group

1282

Group.destroy_all # No fixtures

1305

Group.destroy_all # No fixtures

1283

@user_in_group = User.generate!

1306

@user_in_group = User.generate!

1284

@second_user_in_group = User.generate!

1307

@second_user_in_group = User.generate!

1285

@user_in_group2 = User.generate!

1308

@user_in_group2 = User.generate!

1286

@user_not_in_group = User.generate!

1309

@user_not_in_group = User.generate!

1287

1310

1288

@group = Group.generate!.reload

1311

@group = Group.generate!.reload

1289

@group.users << @user_in_group

1312

@group.users << @user_in_group

1290

@group.users << @second_user_in_group

1313

@group.users << @second_user_in_group

1291

1314

1292

@group2 = Group.generate!.reload

1315

@group2 = Group.generate!.reload

1293

@group2.users << @user_in_group2

1316

@group2.users << @user_in_group2

1294

1317

1295

@query = IssueQuery.new(:name => '_')

1318

@query = IssueQuery.new(:name => '_')

1296

end

1319

end

1297

1320

1298

test "member_of_group filter should search assigned to for users in the group" do

1321

test "member_of_group filter should search assigned to for users in the group" do

1299

setup_member_of_group

1322

setup_member_of_group

1300

@query.add_filter('member_of_group', '=', [@group.id.to_s])

1323

@query.add_filter('member_of_group', '=', [@group.id.to_s])

1301

1324

1302

assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@group.id}')"

1325

assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@group.id}')"

1303

assert_find_issues_with_query_is_successful @query

1326

assert_find_issues_with_query_is_successful @query

1304

end

1327

end

1305

1328

1306

test "member_of_group filter should search not assigned to any group member (none)" do

1329

test "member_of_group filter should search not assigned to any group member (none)" do

1307

setup_member_of_group

1330

setup_member_of_group

1308

@query.add_filter('member_of_group', '!*', [''])

1331

@query.add_filter('member_of_group', '!*', [''])

1309

1332

1310

# Users not in a group

1333

# Users not in a group

1311

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}')"

1334

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}')"

1312

assert_find_issues_with_query_is_successful @query

1335

assert_find_issues_with_query_is_successful @query

1313

end

1336

end

1314

1337

1315

test "member_of_group filter should search assigned to any group member (all)" do

1338

test "member_of_group filter should search assigned to any group member (all)" do

1316

setup_member_of_group

1339

setup_member_of_group

1317

@query.add_filter('member_of_group', '*', [''])

1340

@query.add_filter('member_of_group', '*', [''])

1318

1341

1319

# Only users in a group

1342

# Only users in a group

1320

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}')"

1343

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}')"

1321

assert_find_issues_with_query_is_successful @query

1344

assert_find_issues_with_query_is_successful @query

1322

end

1345

end

1323

1346

1324

test "member_of_group filter should return an empty set with = empty group" do

1347

test "member_of_group filter should return an empty set with = empty group" do

1325

setup_member_of_group

1348

setup_member_of_group

1326

@empty_group = Group.generate!

1349

@empty_group = Group.generate!

1327

@query.add_filter('member_of_group', '=', [@empty_group.id.to_s])

1350

@query.add_filter('member_of_group', '=', [@empty_group.id.to_s])

1328

1351

1329

assert_equal [], find_issues_with_query(@query)

1352

assert_equal [], find_issues_with_query(@query)

1330

end

1353

end

1331

1354

1332

test "member_of_group filter should return issues with ! empty group" do

1355

test "member_of_group filter should return issues with ! empty group" do

1333

setup_member_of_group

1356

setup_member_of_group

1334

@empty_group = Group.generate!

1357

@empty_group = Group.generate!

1335

@query.add_filter('member_of_group', '!', [@empty_group.id.to_s])

1358

@query.add_filter('member_of_group', '!', [@empty_group.id.to_s])

1336

1359

1337

assert_find_issues_with_query_is_successful @query

1360

assert_find_issues_with_query_is_successful @query

1338

end

1361

end

1339

1362

1340

def setup_assigned_to_role

1363

def setup_assigned_to_role

1341

@manager_role = Role.find_by_name('Manager')

1364

@manager_role = Role.find_by_name('Manager')

1342

@developer_role = Role.find_by_name('Developer')

1365

@developer_role = Role.find_by_name('Developer')

1343

1366

1344

@project = Project.generate!

1367

@project = Project.generate!

1345

@manager = User.generate!

1368

@manager = User.generate!

1346

@developer = User.generate!

1369

@developer = User.generate!

1347

@boss = User.generate!

1370

@boss = User.generate!

1348

@guest = User.generate!

1371

@guest = User.generate!

1349

User.add_to_project(@manager, @project, @manager_role)

1372

User.add_to_project(@manager, @project, @manager_role)

1350

User.add_to_project(@developer, @project, @developer_role)

1373

User.add_to_project(@developer, @project, @developer_role)

1351

User.add_to_project(@boss, @project, [@manager_role, @developer_role])

1374

User.add_to_project(@boss, @project, [@manager_role, @developer_role])

1352

1375

1353

@issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)

1376

@issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)

1354

@issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)

1377

@issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)

1355

@issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)

1378

@issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)

1356

@issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)

1379

@issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)

1357

@issue5 = Issue.generate!(:project => @project)

1380

@issue5 = Issue.generate!(:project => @project)

1358

1381

1359

@query = IssueQuery.new(:name => '_', :project => @project)

1382

@query = IssueQuery.new(:name => '_', :project => @project)

1360

end

1383

end

1361

1384

1362

test "assigned_to_role filter should search assigned to for users with the Role" do

1385

test "assigned_to_role filter should search assigned to for users with the Role" do

1363

setup_assigned_to_role

1386

setup_assigned_to_role

1364

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1387

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1365

1388

1366

assert_query_result [@issue1, @issue3], @query

1389

assert_query_result [@issue1, @issue3], @query

1367

end

1390

end

1368

1391

1369

test "assigned_to_role filter should search assigned to for users with the Role on the issue project" do

1392

test "assigned_to_role filter should search assigned to for users with the Role on the issue project" do

1370

setup_assigned_to_role

1393

setup_assigned_to_role

1371

other_project = Project.generate!

1394

other_project = Project.generate!

1372

User.add_to_project(@developer, other_project, @manager_role)

1395

User.add_to_project(@developer, other_project, @manager_role)

1373

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1396

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1374

1397

1375

assert_query_result [@issue1, @issue3], @query

1398

assert_query_result [@issue1, @issue3], @query

1376

end

1399

end

1377

1400

1378

test "assigned_to_role filter should return an empty set with empty role" do

1401

test "assigned_to_role filter should return an empty set with empty role" do

1379

setup_assigned_to_role

1402

setup_assigned_to_role

1380

@empty_role = Role.generate!

1403

@empty_role = Role.generate!

1381

@query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])

1404

@query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])

1382

1405

1383

assert_query_result [], @query

1406

assert_query_result [], @query

1384

end

1407

end

1385

1408

1386

test "assigned_to_role filter should search assigned to for users without the Role" do

1409

test "assigned_to_role filter should search assigned to for users without the Role" do

1387

setup_assigned_to_role

1410

setup_assigned_to_role

1388

@query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])

1411

@query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])

1389

1412

1390

assert_query_result [@issue2, @issue4, @issue5], @query

1413

assert_query_result [@issue2, @issue4, @issue5], @query

1391

end

1414

end

1392

1415

1393

test "assigned_to_role filter should search assigned to for users not assigned to any Role (none)" do

1416

test "assigned_to_role filter should search assigned to for users not assigned to any Role (none)" do

1394

setup_assigned_to_role

1417

setup_assigned_to_role

1395

@query.add_filter('assigned_to_role', '!*', [''])

1418

@query.add_filter('assigned_to_role', '!*', [''])

1396

1419

1397

assert_query_result [@issue4, @issue5], @query

1420

assert_query_result [@issue4, @issue5], @query

1398

end

1421

end

1399

1422

1400

test "assigned_to_role filter should search assigned to for users assigned to any Role (all)" do

1423

test "assigned_to_role filter should search assigned to for users assigned to any Role (all)" do

1401

setup_assigned_to_role

1424

setup_assigned_to_role

1402

@query.add_filter('assigned_to_role', '*', [''])

1425

@query.add_filter('assigned_to_role', '*', [''])

1403

1426

1404

assert_query_result [@issue1, @issue2, @issue3], @query

1427

assert_query_result [@issue1, @issue2, @issue3], @query

1405

end

1428

end

1406

1429

1407

test "assigned_to_role filter should return issues with ! empty role" do

1430

test "assigned_to_role filter should return issues with ! empty role" do

1408

setup_assigned_to_role

1431

setup_assigned_to_role

1409

@empty_role = Role.generate!

1432

@empty_role = Role.generate!

1410

@query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])

1433

@query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])

1411

1434

1412

assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query

1435

assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query

1413

end

1436

end

1414

1437

1415

def test_query_column_should_accept_a_symbol_as_caption

1438

def test_query_column_should_accept_a_symbol_as_caption

1416

set_language_if_valid 'en'

1439

set_language_if_valid 'en'

1417

c = QueryColumn.new('foo', :caption => :general_text_Yes)

1440

c = QueryColumn.new('foo', :caption => :general_text_Yes)

1418

assert_equal 'Yes', c.caption

1441

assert_equal 'Yes', c.caption

1419

end

1442

end

1420

1443

1421

def test_query_column_should_accept_a_proc_as_caption

1444

def test_query_column_should_accept_a_proc_as_caption

1422

c = QueryColumn.new('foo', :caption => lambda {'Foo'})

1445

c = QueryColumn.new('foo', :caption => lambda {'Foo'})

1423

assert_equal 'Foo', c.caption

1446

assert_equal 'Foo', c.caption

1424

end

1447

end

1425

end

1448

end

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

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

             # Redmine - project management software
             # Copyright (C) 2006-2014  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class QueryTest < ActiveSupport::TestCase
               include Redmine::I18n
               fixtures :projects, :enabled_modules, :users, :members,
                        :member_roles, :roles, :trackers, :issue_statuses,
                        :issue_categories, :enumerations, :issues,
                        :watchers, :custom_fields, :custom_values, :versions,
                        :queries,
                        :projects_trackers,
                        :custom_fields_trackers,
                        :workflows
               def test_query_with_roles_visibility_should_validate_roles
                 set_language_if_valid 'en'
                 query = IssueQuery.new(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES)
                 assert !query.save
                 assert_include "Roles can't be blank", query.errors.full_messages
                 query.role_ids = [1, 2]
                 assert query.save
               end
               def test_changing_roles_visibility_should_clear_roles
                 query = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1, 2])
                 assert_equal 2, query.roles.count
                 query.visibility = IssueQuery::VISIBILITY_PUBLIC
                 query.save!
                 assert_equal 0, query.roles.count
               end
               def test_available_filters_should_be_ordered
                 set_language_if_valid 'en'
                 query = IssueQuery.new
                 assert_equal 0, query.available_filters.keys.index('status_id')
                 expected_order = [
                   "Status",
                   "Project",
                   "Tracker",
                   "Priority"
                 ]
                 assert_equal expected_order,
                              (query.available_filters.values.map{|v| v[:name]} & expected_order)
               end
               def test_available_filters_with_custom_fields_should_be_ordered
                 set_language_if_valid 'en'
                 UserCustomField.create!(
                           :name => 'order test', :field_format => 'string',
                           :is_for_all => true, :is_filter => true
                         )
                 query = IssueQuery.new
                 expected_order = [
                   "Searchable field",
                   "Database",
                   "Project's Development status",
                   "Author's order test",
                   "Assignee's order test"
                 ]
                 assert_equal expected_order,
                              (query.available_filters.values.map{|v| v[:name]} & expected_order)
               end
               def test_custom_fields_for_all_projects_should_be_available_in_global_queries
                 query = IssueQuery.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('cf_1')
                 assert !query.available_filters.has_key?('cf_3')
               end
               def test_system_shared_versions_should_be_available_in_global_queries
                 Version.find(2).update_attribute :sharing, 'system'
                 query = IssueQuery.new(:project => nil, :name => '_')
                 assert query.available_filters.has_key?('fixed_version_id')
                 assert query.available_filters['fixed_version_id'][:values].detect {|v| v.last == '2'}
               end
               def test_project_filter_in_global_queries
                 query = IssueQuery.new(:project => nil, :name => '_')
                 project_filter = query.available_filters["project_id"]
                 assert_not_nil project_filter
                 project_ids = project_filter[:values].map{|p| p[1]}
                 assert project_ids.include?("1")  #public project
                 assert !project_ids.include?("2") #private project user cannot see
               end
+              def test_available_filters_should_not_include_fields_disabled_on_all_trackers
+                Tracker.all.each do |tracker|
+                  tracker.core_fields = Tracker::CORE_FIELDS - ['start_date']
+                  tracker.save!
+                end
+                query = IssueQuery.new(:name => '_')
+                assert_include 'due_date', query.available_filters
+                assert_not_include 'start_date', query.available_filters
+              end
               def find_issues_with_query(query)
                 Issue.joins(:status, :tracker, :project, :priority).where(
                      query.statement
                    ).to_a
               end
               def assert_find_issues_with_query_is_successful(query)
                 assert_nothing_raised do
                   find_issues_with_query(query)
                 end
               end
               def assert_query_statement_includes(query, condition)
                 assert_include condition, query.statement
               end
               def assert_query_result(expected, query)
                 assert_nothing_raised do
                   assert_equal expected.map(&:id).sort, query.issues.map(&:id).sort
                   assert_equal expected.size, query.issue_count
                 end
               end
               def test_query_should_allow_shared_versions_for_a_project_query
                 subproject_version = Version.find(4)
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '=', [subproject_version.id.to_s])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IN ('4')")
               end
               def test_query_with_multiple_custom_fields
                 query = IssueQuery.find(1)
                 assert query.valid?
                 assert query.statement.include?("#{CustomValue.table_name}.value IN ('MySQL')")
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.length
                 assert_equal Issue.find(3), issues.first
               end
               def test_operator_none
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '!*', [''])
                 query.add_filter('cf_1', '!*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NULL OR #{CustomValue.table_name}.value = ''")
                 find_issues_with_query(query)
               end
               def test_operator_none_for_integer
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('estimated_hours', '!*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| !i.estimated_hours}
               end
               def test_operator_none_for_date
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('start_date', '!*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.start_date.nil?}
               end
               def test_operator_none_for_string_custom_field
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('cf_2', '!*', [''])
                 assert query.has_filter?('cf_2')
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.custom_field_value(2).blank?}
               end
               def test_operator_all
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('fixed_version_id', '*', [''])
                 query.add_filter('cf_1', '*', [''])
                 assert query.statement.include?("#{Issue.table_name}.fixed_version_id IS NOT NULL")
                 assert query.statement.include?("#{CustomValue.table_name}.value IS NOT NULL AND #{CustomValue.table_name}.value <> ''")
                 find_issues_with_query(query)
               end
               def test_operator_all_for_date
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('start_date', '*', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.start_date.present?}
               end
               def test_operator_all_for_string_custom_field
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('cf_2', '*', [''])
                 assert query.has_filter?('cf_2')
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 assert issues.all? {|i| i.custom_field_value(2).present?}
               end
               def test_numeric_filter_should_not_accept_non_numeric_values
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('estimated_hours', '=', ['a'])
                 assert query.has_filter?('estimated_hours')
                 assert !query.valid?
               end
               def test_operator_is_on_float
                 Issue.where(:id => 2).update_all("estimated_hours = 171.2")
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('estimated_hours', '=', ['171.20'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_integer_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['12'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_integer_custom_field_should_accept_negative_value
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_for_all => true, :is_filter => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['-12'])
                 assert query.valid?
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_float_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12.7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['12.7'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_float_custom_field_should_accept_negative_value
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'float', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7.3')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '-12.7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['-12.7'])
                 assert query.valid?
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_is_on_multi_list_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
                   :possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['value1'])
                 issues = find_issues_with_query(query)
                 assert_equal [1, 3], issues.map(&:id).sort
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '=', ['value2'])
                 issues = find_issues_with_query(query)
                 assert_equal [1], issues.map(&:id).sort
               end
               def test_operator_is_not_on_multi_list_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'list', :is_filter => true, :is_for_all => true,
                   :possible_values => ['value1', 'value2', 'value3'], :multiple => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value1')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => 'value2')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => 'value1')
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '!', ['value1'])
                 issues = find_issues_with_query(query)
                 assert !issues.map(&:id).include?(1)
                 assert !issues.map(&:id).include?(3)
                 query = IssueQuery.new(:name => '_')
                 query.add_filter("cf_#{f.id}", '!', ['value2'])
                 issues = find_issues_with_query(query)
                 assert !issues.map(&:id).include?(1)
                 assert issues.map(&:id).include?(3)
               end
               def test_operator_is_on_is_private_field
                 # is_private filter only available for those who can set issues private
                 User.current = User.find(2)
                 query = IssueQuery.new(:name => '_')
                 assert query.available_filters.key?('is_private')
                 query.add_filter("is_private", '=', ['1'])
                 issues = find_issues_with_query(query)
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.is_private?}
               ensure
                 User.current = nil
               end
               def test_operator_is_not_on_is_private_field
                 # is_private filter only available for those who can set issues private
                 User.current = User.find(2)
                 query = IssueQuery.new(:name => '_')
                 assert query.available_filters.key?('is_private')
                 query.add_filter("is_private", '!', ['1'])
                 issues = find_issues_with_query(query)
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.is_private?}
               ensure
                 User.current = nil
               end
               def test_operator_greater_than
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '>=', ['40'])
                 assert query.statement.include?("#{Issue.table_name}.done_ratio >= 40.0")
                 find_issues_with_query(query)
               end
               def test_operator_greater_than_a_float
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('estimated_hours', '>=', ['40.5'])
                 assert query.statement.include?("#{Issue.table_name}.estimated_hours >= 40.5")
                 find_issues_with_query(query)
               end
               def test_operator_greater_than_on_int_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '7')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '12')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '>=', ['8'])
                 issues = find_issues_with_query(query)
                 assert_equal 1, issues.size
                 assert_equal 2, issues.first.id
               end
               def test_operator_lesser_than
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '<=', ['30'])
                 assert query.statement.include?("#{Issue.table_name}.done_ratio <= 30.0")
                 find_issues_with_query(query)
               end
               def test_operator_lesser_than_on_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '<=', ['30'])
                 assert_match /CAST.+ <= 30\.0/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_lesser_than_on_date_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'date', :is_filter => true, :is_for_all => true, :trackers => Tracker.all)
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(1), :value => '2013-04-11')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(2), :value => '2013-05-14')
                 CustomValue.create!(:custom_field => f, :customized => Issue.find(3), :value => '')
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '<=', ['2013-05-01'])
                 issue_ids = find_issues_with_query(query).map(&:id)
                 assert_include 1, issue_ids
                 assert_not_include 2, issue_ids
                 assert_not_include 3, issue_ids
               end
               def test_operator_between
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('done_ratio', '><', ['30', '40'])
                 assert_include "#{Issue.table_name}.done_ratio BETWEEN 30.0 AND 40.0", query.statement
                 find_issues_with_query(query)
               end
               def test_operator_between_on_custom_field
                 f = IssueCustomField.create!(:name => 'filter', :field_format => 'int', :is_filter => true, :is_for_all => true)
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter("cf_#{f.id}", '><', ['30', '40'])
                 assert_match /CAST.+ BETWEEN 30.0 AND 40.0/, query.statement
                 find_issues_with_query(query)
               end
               def test_date_filter_should_not_accept_non_date_values
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '=', ['a'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_date_filter_should_not_accept_invalid_date_values
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '=', ['2011-01-34'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_relative_date_filter_should_not_accept_non_integer_values
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('created_on', '>t-', ['a'])
                 assert query.has_filter?('created_on')
                 assert !query.valid?
               end
               def test_operator_date_equals
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '=', ['2011-07-10'])
                 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
                 find_issues_with_query(query)
               end
               def test_operator_date_lesser_than
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '<=', ['2011-07-10'])
                 assert_match /issues\.due_date <= '2011-07-10 23:59:59(\.9+)?/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_lesser_than_with_timestamp
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('updated_on', '<=', ['2011-07-10T19:13:52'])
                 assert_match /issues\.updated_on <= '2011-07-10 19:13:52/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_greater_than
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '>=', ['2011-07-10'])
                 assert_match /issues\.due_date > '2011-07-09 23:59:59(\.9+)?'/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_greater_than_with_timestamp
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('updated_on', '>=', ['2011-07-10T19:13:52'])
                 assert_match /issues\.updated_on > '2011-07-10 19:13:51(\.0+)?'/, query.statement
                 find_issues_with_query(query)
               end
               def test_operator_date_between
                 query = IssueQuery.new(:name => '_')
                 query.add_filter('due_date', '><', ['2011-06-23', '2011-07-10'])
                 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
                 find_issues_with_query(query)
               end
               def test_operator_in_more_than
                 Issue.find(7).update_attribute(:due_date, (Date.today + 15))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today + 15))}
               end
               def test_operator_in_less_than
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date <= (Date.today + 15))}
               end
               def test_operator_in_the_next_days
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '><t+', ['15'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= Date.today && issue.due_date <= (Date.today + 15))}
               end
               def test_operator_less_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '>t-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today - 3))}
               end
               def test_operator_in_the_past_days
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '><t-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date >= (Date.today - 3) && issue.due_date <= Date.today)}
               end
               def test_operator_more_than_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 10))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', '<t-', ['10'])
                 assert query.statement.include?("#{Issue.table_name}.due_date <=")
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert(issue.due_date <= (Date.today - 10))}
               end
               def test_operator_in
                 Issue.find(7).update_attribute(:due_date, (Date.today + 2))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't+', ['2'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today + 2), issue.due_date)}
               end
               def test_operator_ago
                 Issue.find(7).update_attribute(:due_date, (Date.today - 3))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't-', ['3'])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal((Date.today - 3), issue.due_date)}
               end
               def test_operator_today
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 't', [''])
                 issues = find_issues_with_query(query)
                 assert !issues.empty?
                 issues.each {|issue| assert_equal Date.today, issue.due_date}
               end
-              def test_operator_this_week_on_date
+              def test_operator_date_periods
-                query = IssueQuery.new(:project => Project.find(1), :name => '_')
+                %w(t ld w lw l2w m lm y).each do |operator|
-                query.add_filter('due_date', 'w', [''])
+                  query = IssueQuery.new(:name => '_')
-                find_issues_with_query(query)
+                  query.add_filter('due_date', operator, [''])
+                  assert query.valid?
+                  assert query.issues
+                end
               end
-              def test_operator_this_week_on_datetime
+              def test_operator_datetime_periods
-                query = IssueQuery.new(:project => Project.find(1), :name => '_')
+                %w(t ld w lw l2w m lm y).each do |operator|
-                query.add_filter('created_on', 'w', [''])
+                  query = IssueQuery.new(:name => '_')
-                find_issues_with_query(query)
+                  query.add_filter('created_on', operator, [''])
+                  assert query.valid?
+                  assert query.issues
+                end
               end
               def test_operator_contains
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) LIKE '%unable%'")
                 result = find_issues_with_query(query)
                 assert result.empty?
                 result.each {|issue| assert issue.subject.downcase.include?('unable') }
               end
               def test_range_for_this_week_with_week_starting_on_monday
                 I18n.locale = :fr
                 assert_equal '1', I18n.t(:general_first_day_of_week)
                 Date.stubs(:today).returns(Date.parse('2011-04-29'))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 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}"
                 I18n.locale = :en
               end
               def test_range_for_this_week_with_week_starting_on_sunday
                 I18n.locale = :en
                 assert_equal '7', I18n.t(:general_first_day_of_week)
                 Date.stubs(:today).returns(Date.parse('2011-04-29'))
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 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}"
               end
               def test_operator_does_not_contains
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('subject', '!~', ['uNable'])
                 assert query.statement.include?("LOWER(#{Issue.table_name}.subject) NOT LIKE '%unable%'")
                 find_issues_with_query(query)
               end
               def test_filter_assigned_to_me
                 user = User.find(2)
                 group = Group.find(10)
                 User.current = user
                 i1 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => user)
                 i2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => group)
                 i3 = Issue.generate!(:project_id => 1, :tracker_id => 1, :assigned_to => Group.find(11))
                 group.users << user
                 query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
                 result = query.issues
                 assert_equal Issue.visible.where(:assigned_to_id => ([2] + user.reload.group_ids)).sort_by(&:id), result.sort_by(&:id)
                 assert result.include?(i1)
                 assert result.include?(i2)
                 assert !result.include?(i3)
               end
               def test_user_custom_field_filtered_on_me
                 User.current = User.find(2)
                 cf = IssueCustomField.create!(:field_format => 'user', :is_for_all => true, :is_filter => true, :name => 'User custom field', :tracker_ids => [1])
                 issue1 = Issue.create!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '2'}, :subject => 'Test', :author_id => 1)
                 issue2 = Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {cf.id.to_s => '3'})
                 query = IssueQuery.new(:name => '_', :project => Project.find(1))
                 filter = query.available_filters["cf_#{cf.id}"]
                 assert_not_nil filter
                 assert_include 'me', filter[:values].map{|v| v[1]}
                 query.filters = { "cf_#{cf.id}" => {:operator => '=', :values => ['me']}}
                 result = query.issues
                 assert_equal 1, result.size
                 assert_equal issue1, result.first
               end
+              def test_filter_on_me_by_anonymous_user
+                User.current = nil
+                query = IssueQuery.new(:name => '_', :filters => { 'assigned_to_id' => {:operator => '=', :values => ['me']}})
+                assert_equal [], query.issues
+              end
               def test_filter_my_projects
                 User.current = User.find(2)
                 query = IssueQuery.new(:name => '_')
                 filter = query.available_filters['project_id']
                 assert_not_nil filter
                 assert_include 'mine', filter[:values].map{|v| v[1]}
                 query.filters = { 'project_id' => {:operator => '=', :values => ['mine']}}
                 result = query.issues
                 assert_nil result.detect {|issue| !User.current.member_of?(issue.project)}
               end
               def test_filter_watched_issues
                 User.current = User.find(1)
                 query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '=', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal Issue.visible.watched_by(User.current).sort_by(&:id), result.sort_by(&:id)
                 User.current = nil
               end
               def test_filter_unwatched_issues
                 User.current = User.find(1)
                 query = IssueQuery.new(:name => '_', :filters => { 'watcher_id' => {:operator => '!', :values => ['me']}})
                 result = find_issues_with_query(query)
                 assert_not_nil result
                 assert !result.empty?
                 assert_equal((Issue.visible - Issue.watched_by(User.current)).sort_by(&:id).size, result.sort_by(&:id).size)
                 User.current = nil
               end
               def test_filter_on_custom_field_should_ignore_projects_with_field_disabled
                 field = IssueCustomField.generate!(:trackers => Tracker.all, :project_ids => [1, 3, 4], :is_filter => true)
                 Issue.generate!(:project_id => 3, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})
                 Issue.generate!(:project_id => 4, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})
                 query = IssueQuery.new(:name => '_', :project => Project.find(1))
                 query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}
                 assert_equal 2, find_issues_with_query(query).size
                 field.project_ids = [1, 3] # Disable the field for project 4
                 field.save!
                 assert_equal 1, find_issues_with_query(query).size
               end
               def test_filter_on_custom_field_should_ignore_trackers_with_field_disabled
                 field = IssueCustomField.generate!(:tracker_ids => [1, 2], :is_for_all => true, :is_filter => true)
                 Issue.generate!(:project_id => 1, :tracker_id => 1, :custom_field_values => {field.id.to_s => 'Foo'})
                 Issue.generate!(:project_id => 1, :tracker_id => 2, :custom_field_values => {field.id.to_s => 'Foo'})
                 query = IssueQuery.new(:name => '_', :project => Project.find(1))
                 query.filters = {"cf_#{field.id}" => {:operator => '=', :values => ['Foo']}}
                 assert_equal 2, find_issues_with_query(query).size
                 field.tracker_ids = [1] # Disable the field for tracker 2
                 field.save!
                 assert_equal 1, find_issues_with_query(query).size
               end
               def test_filter_on_project_custom_field
                 field = ProjectCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => Project.find(3), :value => 'Foo')
                 CustomValue.create!(:custom_field => field, :customized => Project.find(5), :value => 'Foo')
                 query = IssueQuery.new(:name => '_')
                 filter_name = "project.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3, 5], find_issues_with_query(query).map(&:project_id).uniq.sort
               end
               def test_filter_on_author_custom_field
                 field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
                 query = IssueQuery.new(:name => '_')
                 filter_name = "author.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3], find_issues_with_query(query).map(&:author_id).uniq.sort
               end
               def test_filter_on_assigned_to_custom_field
                 field = UserCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => User.find(3), :value => 'Foo')
                 query = IssueQuery.new(:name => '_')
                 filter_name = "assigned_to.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [3], find_issues_with_query(query).map(&:assigned_to_id).uniq.sort
               end
               def test_filter_on_fixed_version_custom_field
                 field = VersionCustomField.create!(:name => 'Client', :is_filter => true, :field_format => 'string')
                 CustomValue.create!(:custom_field => field, :customized => Version.find(2), :value => 'Foo')
                 query = IssueQuery.new(:name => '_')
                 filter_name = "fixed_version.cf_#{field.id}"
                 assert_include filter_name, query.available_filters.keys
                 query.filters = {filter_name => {:operator => '=', :values => ['Foo']}}
                 assert_equal [2], find_issues_with_query(query).map(&:fixed_version_id).uniq.sort
               end
               def test_filter_on_relations_with_a_specific_issue
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=', :values => ['1']}}
                 assert_equal [2, 3], find_issues_with_query(query).map(&:id).sort
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=', :values => ['2']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_any_issues_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
                 end
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['2']}}
                 assert_equal [1, 2], find_issues_with_query(query).map(&:id).sort
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['3']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=p', :values => ['4']}}
                 assert_equal [], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_any_issues_not_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   #IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(1).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(3).issues.first)
                 end
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '=!p', :values => ['1']}}
                 assert_equal [1], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_with_no_issues_in_a_project
                 IssueRelation.delete_all
                 with_settings :cross_project_issue_relations => '1' do
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Project.find(2).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(2), :issue_to => Project.find(3).issues.first)
                   IssueRelation.create!(:relation_type => "relates", :issue_to => Project.find(2).issues.first, :issue_from => Issue.find(3))
                 end
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '!p', :values => ['2']}}
                 ids = find_issues_with_query(query).map(&:id).sort
                 assert_include 2, ids
                 assert_not_include 1, ids
                 assert_not_include 3, ids
               end
               def test_filter_on_relations_with_no_issues
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '!*', :values => ['']}}
                 ids = find_issues_with_query(query).map(&:id)
                 assert_equal [], ids & [1, 2, 3]
                 assert_include 4, ids
               end
               def test_filter_on_relations_with_any_issues
                 IssueRelation.delete_all
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(1), :issue_to => Issue.find(2))
                 IssueRelation.create!(:relation_type => "relates", :issue_from => Issue.find(3), :issue_to => Issue.find(1))
                 query = IssueQuery.new(:name => '_')
                 query.filters = {"relates" => {:operator => '*', :values => ['']}}
                 assert_equal [1, 2, 3], find_issues_with_query(query).map(&:id).sort
               end
               def test_filter_on_relations_should_not_ignore_other_filter
                 issue = Issue.generate!
                 issue1 = Issue.generate!(:status_id => 1)
                 issue2 = Issue.generate!(:status_id => 2)
                 IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue1)
                 IssueRelation.create!(:relation_type => "relates", :issue_from => issue, :issue_to => issue2)
                 query = IssueQuery.new(:name => '_')
                 query.filters = {
                   "status_id" => {:operator => '=', :values => ['1']},
                   "relates" => {:operator => '=', :values => [issue.id.to_s]}
                 }
                 assert_equal [issue1], find_issues_with_query(query)
               end
               def test_statement_should_be_nil_with_no_filters
                 q = IssueQuery.new(:name => '_')
                 q.filters = {}
                 assert q.valid?
                 assert_nil q.statement
               end
               def test_default_columns
                 q = IssueQuery.new
                 assert q.columns.any?
                 assert q.inline_columns.any?
                 assert q.block_columns.empty?
               end
               def test_set_column_names
                 q = IssueQuery.new
                 q.column_names = ['tracker', :subject, '', 'unknonw_column']
                 assert_equal [:id, :tracker, :subject], q.columns.collect {|c| c.name}
               end
               def test_has_column_should_accept_a_column_name
                 q = IssueQuery.new
                 q.column_names = ['tracker', :subject]
                 assert q.has_column?(:tracker)
                 assert !q.has_column?(:category)
               end
               def test_has_column_should_accept_a_column
                 q = IssueQuery.new
                 q.column_names = ['tracker', :subject]
                 tracker_column = q.available_columns.detect {|c| c.name==:tracker}
                 assert_kind_of QueryColumn, tracker_column
                 category_column = q.available_columns.detect {|c| c.name==:category}
                 assert_kind_of QueryColumn, category_column
                 assert q.has_column?(tracker_column)
                 assert !q.has_column?(category_column)
               end
               def test_inline_and_block_columns
                 q = IssueQuery.new
                 q.column_names = ['subject', 'description', 'tracker']
                 assert_equal [:id, :subject, :tracker], q.inline_columns.map(&:name)
                 assert_equal [:description], q.block_columns.map(&:name)
               end
               def test_custom_field_columns_should_be_inline
                 q = IssueQuery.new
                 columns = q.available_columns.select {|column| column.is_a? QueryCustomFieldColumn}
                 assert columns.any?
                 assert_nil columns.detect {|column| !column.inline?}
               end
               def test_query_should_preload_spent_hours
                 q = IssueQuery.new(:name => '_', :column_names => [:subject, :spent_hours])
                 assert q.has_column?(:spent_hours)
                 issues = q.issues
                 assert_not_nil issues.first.instance_variable_get("@spent_hours")
               end
               def test_groupable_columns_should_include_custom_fields
                 q = IssueQuery.new
                 column = q.groupable_columns.detect {|c| c.name == :cf_1}
                 assert_not_nil column
                 assert_kind_of QueryCustomFieldColumn, column
               end
               def test_groupable_columns_should_not_include_multi_custom_fields
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 q = IssueQuery.new
                 column = q.groupable_columns.detect {|c| c.name == :cf_1}
                 assert_nil column
               end
               def test_groupable_columns_should_include_user_custom_fields
                 cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'user')
                 q = IssueQuery.new
                 assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
               end
               def test_groupable_columns_should_include_version_custom_fields
                 cf = IssueCustomField.create!(:name => 'User', :is_for_all => true, :tracker_ids => [1], :field_format => 'version')
                 q = IssueQuery.new
                 assert q.groupable_columns.detect {|c| c.name == "cf_#{cf.id}".to_sym}
               end
               def test_grouped_with_valid_column
                 q = IssueQuery.new(:group_by => 'status')
                 assert q.grouped?
                 assert_not_nil q.group_by_column
                 assert_equal :status, q.group_by_column.name
                 assert_not_nil q.group_by_statement
                 assert_equal 'status', q.group_by_statement
               end
               def test_grouped_with_invalid_column
                 q = IssueQuery.new(:group_by => 'foo')
                 assert !q.grouped?
                 assert_nil q.group_by_column
                 assert_nil q.group_by_statement
               end
               def test_sortable_columns_should_sort_assignees_according_to_user_format_setting
                 with_settings :user_format => 'lastname_coma_firstname' do
                   q = IssueQuery.new
                   assert q.sortable_columns.has_key?('assigned_to')
                   assert_equal %w(users.lastname users.firstname users.id), q.sortable_columns['assigned_to']
                 end
               end
               def test_sortable_columns_should_sort_authors_according_to_user_format_setting
                 with_settings :user_format => 'lastname_coma_firstname' do
                   q = IssueQuery.new
                   assert q.sortable_columns.has_key?('author')
                   assert_equal %w(authors.lastname authors.firstname authors.id), q.sortable_columns['author']
                 end
               end
               def test_sortable_columns_should_include_custom_field
                 q = IssueQuery.new
                 assert q.sortable_columns['cf_1']
               end
               def test_sortable_columns_should_not_include_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 q = IssueQuery.new
                 assert !q.sortable_columns['cf_1']
               end
               def test_default_sort
                 q = IssueQuery.new
                 assert_equal [], q.sort_criteria
               end
               def test_set_sort_criteria_with_hash
                 q = IssueQuery.new
                 q.sort_criteria = {'0' => ['priority', 'desc'], '2' => ['tracker']}
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_set_sort_criteria_with_array
                 q = IssueQuery.new
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_create_query_with_sort
                 q = IssueQuery.new(:name => 'Sorted')
                 q.sort_criteria = [['priority', 'desc'], 'tracker']
                 assert q.save
                 q.reload
                 assert_equal [['priority', 'desc'], ['tracker', 'asc']], q.sort_criteria
               end
               def test_sort_by_string_custom_field_asc
                 q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = q.issues(:order => "#{c.sortable} ASC")
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_sort_by_string_custom_field_desc
                 q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'string' }
                 assert c
                 assert c.sortable
                 issues = q.issues(:order => "#{c.sortable} DESC")
                 values = issues.collect {|i| i.custom_value_for(c.custom_field).to_s}
                 assert !values.empty?
                 assert_equal values.sort.reverse, values
               end
               def test_sort_by_float_custom_field_asc
                 q = IssueQuery.new
                 c = q.available_columns.find {|col| col.is_a?(QueryCustomFieldColumn) && col.custom_field.field_format == 'float' }
                 assert c
                 assert c.sortable
                 issues = q.issues(:order => "#{c.sortable} ASC")
                 values = issues.collect {|i| begin; Kernel.Float(i.custom_value_for(c.custom_field).to_s); rescue; nil; end}.compact
                 assert !values.empty?
                 assert_equal values.sort, values
               end
               def test_invalid_query_should_raise_query_statement_invalid_error
                 q = IssueQuery.new
                 assert_raise Query::StatementInvalid do
                   q.issues(:conditions => "foo = 1")
                 end
               end
               def test_issue_count
                 q = IssueQuery.new(:name => '_')
                 issue_count = q.issue_count
                 assert_equal q.issues.size, issue_count
               end
               def test_issue_count_with_archived_issues
                 p = Project.generate! do |project|
                   project.status = Project::STATUS_ARCHIVED
                 end
                 i = Issue.generate!( :project => p, :tracker => p.trackers.first )
                 assert !i.visible?
                 test_issue_count
               end
               def test_issue_count_by_association_group
                 q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass User), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?(User.find(3))
               end
               def test_issue_count_by_list_custom_field_group
                 q = IssueQuery.new(:name => '_', :group_by => 'cf_1')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(NilClass String), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
                 assert count_by_group.has_key?('MySQL')
               end
               def test_issue_count_by_date_custom_field_group
                 q = IssueQuery.new(:name => '_', :group_by => 'cf_8')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal %w(Date NilClass), count_by_group.keys.collect {|k| k.class.name}.uniq.sort
                 assert_equal %w(Fixnum), count_by_group.values.collect {|k| k.class.name}.uniq
               end
               def test_issue_count_with_nil_group_only
                 Issue.update_all("assigned_to_id = NULL")
                 q = IssueQuery.new(:name => '_', :group_by => 'assigned_to')
                 count_by_group = q.issue_count_by_group
                 assert_kind_of Hash, count_by_group
                 assert_equal 1, count_by_group.keys.size
                 assert_nil count_by_group.keys.first
               end
               def test_issue_ids
                 q = IssueQuery.new(:name => '_')
                 order = "issues.subject, issues.id"
                 issues = q.issues(:order => order)
                 assert_equal issues.map(&:id), q.issue_ids(:order => order)
               end
               def test_label_for
                 set_language_if_valid 'en'
                 q = IssueQuery.new
                 assert_equal 'Assignee', q.label_for('assigned_to_id')
               end
               def test_label_for_fr
                 set_language_if_valid 'fr'
                 q = IssueQuery.new
                 assert_equal "Assign\xc3\xa9 \xc3\xa0".force_encoding('UTF-8'), q.label_for('assigned_to_id')
               end
               def test_editable_by
                 admin = User.find(1)
                 manager = User.find(2)
                 developer = User.find(3)
                 # Public query on project 1
                 q = IssueQuery.find(1)
                 assert q.editable_by?(admin)
                 assert q.editable_by?(manager)
                 assert !q.editable_by?(developer)
                 # Private query on project 1
                 q = IssueQuery.find(2)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Private query for all projects
                 q = IssueQuery.find(3)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert q.editable_by?(developer)
                 # Public query for all projects
                 q = IssueQuery.find(4)
                 assert q.editable_by?(admin)
                 assert !q.editable_by?(manager)
                 assert !q.editable_by?(developer)
               end
               def test_visible_scope
                 query_ids = IssueQuery.visible(User.anonymous).map(&:id)
                 assert query_ids.include?(1), 'public query on public project was not visible'
                 assert query_ids.include?(4), 'public query for all projects was not visible'
                 assert !query_ids.include?(2), 'private query on public project was visible'
                 assert !query_ids.include?(3), 'private query for all projects was visible'
                 assert !query_ids.include?(7), 'public query on private project was visible'
               end
               def test_query_with_public_visibility_should_be_visible_to_anyone
                 q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)
                 assert q.visible?(User.anonymous)
                 assert IssueQuery.visible(User.anonymous).find_by_id(q.id)
                 assert q.visible?(User.find(7))
                 assert IssueQuery.visible(User.find(7)).find_by_id(q.id)
                 assert q.visible?(User.find(2))
                 assert IssueQuery.visible(User.find(2)).find_by_id(q.id)
                 assert q.visible?(User.find(1))
                 assert IssueQuery.visible(User.find(1)).find_by_id(q.id)
               end
               def test_query_with_roles_visibility_should_be_visible_to_user_with_role
                 q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_ROLES, :role_ids => [1,2])
                 assert !q.visible?(User.anonymous)
                 assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)
                 assert !q.visible?(User.find(7))
                 assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)
                 assert q.visible?(User.find(2))
                 assert IssueQuery.visible(User.find(2)).find_by_id(q.id)
                 assert q.visible?(User.find(1))
                 assert IssueQuery.visible(User.find(1)).find_by_id(q.id)
               end
               def test_query_with_private_visibility_should_be_visible_to_owner
                 q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PRIVATE, :user => User.find(7))
                 assert !q.visible?(User.anonymous)
                 assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)
                 assert q.visible?(User.find(7))
                 assert IssueQuery.visible(User.find(7)).find_by_id(q.id)
                 assert !q.visible?(User.find(2))
                 assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)
                 assert q.visible?(User.find(1))
                 assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)
               end
               test "#available_filters should include users of visible projects in cross-project view" do
                 users = IssueQuery.new.available_filters["assigned_to_id"]
                 assert_not_nil users
                 assert users[:values].map{|u|u[1]}.include?("3")
               end
               test "#available_filters should include users of subprojects" do
                 user1 = User.generate!
                 user2 = User.generate!
                 project = Project.find(1)
                 Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])
                 users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]
                 assert_not_nil users
                 assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)
                 assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)
               end
               test "#available_filters should include visible projects in cross-project view" do
                 projects = IssueQuery.new.available_filters["project_id"]
                 assert_not_nil projects
                 assert projects[:values].map{|u|u[1]}.include?("1")
               end
               test "#available_filters should include 'member_of_group' filter" do
                 query = IssueQuery.new
                 assert query.available_filters.keys.include?("member_of_group")
                 assert_equal :list_optional, query.available_filters["member_of_group"][:type]
                 assert query.available_filters["member_of_group"][:values].present?
                 assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},
                   query.available_filters["member_of_group"][:values].sort
               end
               test "#available_filters should include 'assigned_to_role' filter" do
                 query = IssueQuery.new
                 assert query.available_filters.keys.include?("assigned_to_role")
                 assert_equal :list_optional, query.available_filters["assigned_to_role"][:type]
                 assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])
                 assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])
                 assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])
                 assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])
                 assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])
               end
               def test_available_filters_should_include_custom_field_according_to_user_visibility
                 visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)
                 hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])
                 with_current_user User.find(3) do
                   query = IssueQuery.new
                   assert_include "cf_#{visible_field.id}", query.available_filters.keys
                   assert_not_include "cf_#{hidden_field.id}", query.available_filters.keys
                 end
               end
               def test_available_columns_should_include_custom_field_according_to_user_visibility
                 visible_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => true)
                 hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])
                 with_current_user User.find(3) do
                   query = IssueQuery.new
                   assert_include :"cf_#{visible_field.id}", query.available_columns.map(&:name)
                   assert_not_include :"cf_#{hidden_field.id}", query.available_columns.map(&:name)
                 end
               end
               def setup_member_of_group
                 Group.destroy_all # No fixtures
                 @user_in_group = User.generate!
                 @second_user_in_group = User.generate!
                 @user_in_group2 = User.generate!
                 @user_not_in_group = User.generate!
                 @group = Group.generate!.reload
                 @group.users << @user_in_group
                 @group.users << @second_user_in_group
                 @group2 = Group.generate!.reload
                 @group2.users << @user_in_group2
                 @query = IssueQuery.new(:name => '_')
               end
               test "member_of_group filter should search assigned to for users in the group" do
                 setup_member_of_group
                 @query.add_filter('member_of_group', '=', [@group.id.to_s])
                 assert_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@group.id}')"
                 assert_find_issues_with_query_is_successful @query
               end
               test "member_of_group filter should search not assigned to any group member (none)" do
                 setup_member_of_group
                 @query.add_filter('member_of_group', '!*', [''])
                 # Users not in a group
                 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}')"
                 assert_find_issues_with_query_is_successful @query
               end
               test "member_of_group filter should search assigned to any group member (all)" do
                 setup_member_of_group
                 @query.add_filter('member_of_group', '*', [''])
                 # Only users in a group
                 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}')"
                 assert_find_issues_with_query_is_successful @query
               end
               test "member_of_group filter should return an empty set with = empty group" do
                 setup_member_of_group
                 @empty_group = Group.generate!
                 @query.add_filter('member_of_group', '=', [@empty_group.id.to_s])
                 assert_equal [], find_issues_with_query(@query)
               end
               test "member_of_group filter should return issues with ! empty group" do
                 setup_member_of_group
                 @empty_group = Group.generate!
                 @query.add_filter('member_of_group', '!', [@empty_group.id.to_s])
                 assert_find_issues_with_query_is_successful @query
               end
               def setup_assigned_to_role
                 @manager_role = Role.find_by_name('Manager')
                 @developer_role = Role.find_by_name('Developer')
                 @project = Project.generate!
                 @manager = User.generate!
                 @developer = User.generate!
                 @boss = User.generate!
                 @guest = User.generate!
                 User.add_to_project(@manager, @project, @manager_role)
                 User.add_to_project(@developer, @project, @developer_role)
                 User.add_to_project(@boss, @project, [@manager_role, @developer_role])
                 @issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)
                 @issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)
                 @issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)
                 @issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)
                 @issue5 = Issue.generate!(:project => @project)
                 @query = IssueQuery.new(:name => '_', :project => @project)
               end
               test "assigned_to_role filter should search assigned to for users with the Role" do
                 setup_assigned_to_role
                 @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                 assert_query_result [@issue1, @issue3], @query
               end
               test "assigned_to_role filter should search assigned to for users with the Role on the issue project" do
                 setup_assigned_to_role
                 other_project = Project.generate!
                 User.add_to_project(@developer, other_project, @manager_role)
                 @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                 assert_query_result [@issue1, @issue3], @query
               end
               test "assigned_to_role filter should return an empty set with empty role" do
                 setup_assigned_to_role
                 @empty_role = Role.generate!
                 @query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])
                 assert_query_result [], @query
               end
               test "assigned_to_role filter should search assigned to for users without the Role" do
                 setup_assigned_to_role
                 @query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])
                 assert_query_result [@issue2, @issue4, @issue5], @query
               end
               test "assigned_to_role filter should search assigned to for users not assigned to any Role (none)" do
                 setup_assigned_to_role
                 @query.add_filter('assigned_to_role', '!*', [''])
                 assert_query_result [@issue4, @issue5], @query
               end
               test "assigned_to_role filter should search assigned to for users assigned to any Role (all)" do
                 setup_assigned_to_role
                 @query.add_filter('assigned_to_role', '*', [''])
                 assert_query_result [@issue1, @issue2, @issue3], @query
               end
               test "assigned_to_role filter should return issues with ! empty role" do
                 setup_assigned_to_role
                 @empty_role = Role.generate!
                 @query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])
                 assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query
               end
               def test_query_column_should_accept_a_symbol_as_caption
                 set_language_if_valid 'en'
                 c = QueryColumn.new('foo', :caption => :general_text_Yes)
                 assert_equal 'Yes', c.caption
               end
               def test_query_column_should_accept_a_proc_as_caption
                 c = QueryColumn.new('foo', :caption => lambda {'Foo'})
                 assert_equal 'Foo', c.caption
               end
             end