jro_apps/redmine Commit - r13176:bc3bd8aff2a7

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 find_issues_with_query(query)

104

def find_issues_with_query(query)

105

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

105

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

106

query.statement

106

query.statement

107

).to_a

107

).to_a

108

end

108

end

109

110

def assert_find_issues_with_query_is_successful(query)

110

def assert_find_issues_with_query_is_successful(query)

111

assert_nothing_raised do

111

assert_nothing_raised do

112

find_issues_with_query(query)

112

find_issues_with_query(query)

113

end

113

end

114

end

114

end

115

116

def assert_query_statement_includes(query, condition)

116

def assert_query_statement_includes(query, condition)

117

assert_include condition, query.statement

117

assert_include condition, query.statement

118

end

118

end

119

120

def assert_query_result(expected, query)

120

def assert_query_result(expected, query)

121

assert_nothing_raised do

121

assert_nothing_raised do

122

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

122

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

123

assert_equal expected.size, query.issue_count

123

assert_equal expected.size, query.issue_count

124

end

124

end

125

end

125

end

126

127

def test_query_should_allow_shared_versions_for_a_project_query

127

def test_query_should_allow_shared_versions_for_a_project_query

128

subproject_version = Version.find(4)

128

subproject_version = Version.find(4)

129

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

129

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

130

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

130

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

131

132

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

132

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

133

end

133

end

134

135

def test_query_with_multiple_custom_fields

135

def test_query_with_multiple_custom_fields

136

query = IssueQuery.find(1)

136

query = IssueQuery.find(1)

137

assert query.valid?

137

assert query.valid?

138

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

138

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

139

issues = find_issues_with_query(query)

139

issues = find_issues_with_query(query)

140

assert_equal 1, issues.length

140

assert_equal 1, issues.length

141

assert_equal Issue.find(3), issues.first

141

assert_equal Issue.find(3), issues.first

142

end

142

end

143

144

def test_operator_none

144

def test_operator_none

145

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

145

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

146

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

146

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

147

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

147

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

148

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

148

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 = ''")

149

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

150

find_issues_with_query(query)

150

find_issues_with_query(query)

151

end

151

end

152

153

def test_operator_none_for_integer

153

def test_operator_none_for_integer

154

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

154

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

155

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

155

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

156

issues = find_issues_with_query(query)

156

issues = find_issues_with_query(query)

157

assert !issues.empty?

157

assert !issues.empty?

158

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

158

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

159

end

159

end

160

161

def test_operator_none_for_date

161

def test_operator_none_for_date

162

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

162

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

163

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

163

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

164

issues = find_issues_with_query(query)

164

issues = find_issues_with_query(query)

165

assert !issues.empty?

165

assert !issues.empty?

166

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

166

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

167

end

167

end

168

169

def test_operator_none_for_string_custom_field

169

def test_operator_none_for_string_custom_field

170

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

170

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

171

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

171

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

172

assert query.has_filter?('cf_2')

172

assert query.has_filter?('cf_2')

173

issues = find_issues_with_query(query)

173

issues = find_issues_with_query(query)

174

assert !issues.empty?

174

assert !issues.empty?

175

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

175

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

176

end

176

end

177

178

def test_operator_all

178

def test_operator_all

179

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

179

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

180

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

180

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

181

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

181

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

182

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

182

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 <> ''")

183

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

184

find_issues_with_query(query)

184

find_issues_with_query(query)

185

end

185

end

186

187

def test_operator_all_for_date

187

def test_operator_all_for_date

188

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

188

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

189

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

189

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

190

issues = find_issues_with_query(query)

190

issues = find_issues_with_query(query)

191

assert !issues.empty?

191

assert !issues.empty?

192

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

192

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

193

end

193

end

194

195

def test_operator_all_for_string_custom_field

195

def test_operator_all_for_string_custom_field

196

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

196

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

197

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

197

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

198

assert query.has_filter?('cf_2')

198

assert query.has_filter?('cf_2')

199

issues = find_issues_with_query(query)

199

issues = find_issues_with_query(query)

200

assert !issues.empty?

200

assert !issues.empty?

201

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

201

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

202

end

202

end

203

204

def test_numeric_filter_should_not_accept_non_numeric_values

204

def test_numeric_filter_should_not_accept_non_numeric_values

205

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

205

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

206

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

206

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

207

208

assert query.has_filter?('estimated_hours')

208

assert query.has_filter?('estimated_hours')

209

assert !query.valid?

209

assert !query.valid?

210

end

210

end

211

212

def test_operator_is_on_float

212

def test_operator_is_on_float

213

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

213

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

214

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

214

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

215

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

215

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

216

issues = find_issues_with_query(query)

216

issues = find_issues_with_query(query)

217

assert_equal 1, issues.size

217

assert_equal 1, issues.size

218

assert_equal 2, issues.first.id

218

assert_equal 2, issues.first.id

219

end

219

end

220

221

def test_operator_is_on_integer_custom_field

221

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)

222

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')

223

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

224

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

224

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

225

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

225

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

226

227

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

227

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

228

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

228

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

229

issues = find_issues_with_query(query)

229

issues = find_issues_with_query(query)

230

assert_equal 1, issues.size

230

assert_equal 1, issues.size

231

assert_equal 2, issues.first.id

231

assert_equal 2, issues.first.id

232

end

232

end

233

234

def test_operator_is_on_integer_custom_field_should_accept_negative_value

234

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)

235

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')

236

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

237

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

237

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

238

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

238

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

239

240

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

240

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

241

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

241

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

242

assert query.valid?

242

assert query.valid?

243

issues = find_issues_with_query(query)

243

issues = find_issues_with_query(query)

244

assert_equal 1, issues.size

244

assert_equal 1, issues.size

245

assert_equal 2, issues.first.id

245

assert_equal 2, issues.first.id

246

end

246

end

247

248

def test_operator_is_on_float_custom_field

248

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)

249

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')

250

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')

251

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

252

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

252

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

253

254

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

254

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

255

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

255

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

256

issues = find_issues_with_query(query)

256

issues = find_issues_with_query(query)

257

assert_equal 1, issues.size

257

assert_equal 1, issues.size

258

assert_equal 2, issues.first.id

258

assert_equal 2, issues.first.id

259

end

259

end

260

261

def test_operator_is_on_float_custom_field_should_accept_negative_value

261

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)

262

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')

263

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')

264

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

265

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

265

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

266

267

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

267

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

268

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

268

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

269

assert query.valid?

269

assert query.valid?

270

issues = find_issues_with_query(query)

270

issues = find_issues_with_query(query)

271

assert_equal 1, issues.size

271

assert_equal 1, issues.size

272

assert_equal 2, issues.first.id

272

assert_equal 2, issues.first.id

273

end

273

end

274

275

def test_operator_is_on_multi_list_custom_field

275

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,

276

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)

277

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

278

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

278

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

279

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

279

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

280

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

280

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

281

282

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

282

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

283

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

283

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

284

issues = find_issues_with_query(query)

284

issues = find_issues_with_query(query)

285

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

285

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

286

287

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

287

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

288

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

288

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

289

issues = find_issues_with_query(query)

289

issues = find_issues_with_query(query)

290

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

290

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

291

end

291

end

292

293

def test_operator_is_not_on_multi_list_custom_field

293

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,

294

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)

295

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

296

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

296

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

297

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

297

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

298

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

298

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

299

300

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

300

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

301

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

301

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

302

issues = find_issues_with_query(query)

302

issues = find_issues_with_query(query)

303

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

303

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

304

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

304

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

305

306

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

306

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

307

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

307

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

308

issues = find_issues_with_query(query)

308

issues = find_issues_with_query(query)

309

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

309

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

310

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

310

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

311

end

311

end

312

313

def test_operator_is_on_is_private_field

313

def test_operator_is_on_is_private_field

314

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

314

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

315

User.current = User.find(2)

315

User.current = User.find(2)

316

317

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

317

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

318

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

318

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

319

320

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

320

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

321

issues = find_issues_with_query(query)

321

issues = find_issues_with_query(query)

322

assert issues.any?

322

assert issues.any?

323

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

323

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

324

ensure

324

ensure

325

User.current = nil

325

User.current = nil

326

end

326

end

327

328

def test_operator_is_not_on_is_private_field

328

def test_operator_is_not_on_is_private_field

329

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

329

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

330

User.current = User.find(2)

330

User.current = User.find(2)

331

332

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

332

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

333

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

333

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

334

335

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

335

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

336

issues = find_issues_with_query(query)

336

issues = find_issues_with_query(query)

337

assert issues.any?

337

assert issues.any?

338

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

338

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

339

ensure

339

ensure

340

User.current = nil

340

User.current = nil

341

end

341

end

342

343

def test_operator_greater_than

343

def test_operator_greater_than

344

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

344

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

345

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

345

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

346

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

346

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

347

find_issues_with_query(query)

347

find_issues_with_query(query)

348

end

348

end

349

350

def test_operator_greater_than_a_float

350

def test_operator_greater_than_a_float

351

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

351

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

352

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

352

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

353

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

353

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

354

find_issues_with_query(query)

354

find_issues_with_query(query)

355

end

355

end

356

357

def test_operator_greater_than_on_int_custom_field

357

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)

358

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')

359

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

360

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

360

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

361

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

361

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

362

363

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

363

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

364

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

364

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

365

issues = find_issues_with_query(query)

365

issues = find_issues_with_query(query)

366

assert_equal 1, issues.size

366

assert_equal 1, issues.size

367

assert_equal 2, issues.first.id

367

assert_equal 2, issues.first.id

368

end

368

end

369

370

def test_operator_lesser_than

370

def test_operator_lesser_than

371

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

371

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

372

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

372

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

373

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

373

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

374

find_issues_with_query(query)

374

find_issues_with_query(query)

375

end

375

end

376

377

def test_operator_lesser_than_on_custom_field

377

def test_operator_lesser_than_on_custom_field

378

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

378

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

379

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

379

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

380

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

380

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

381

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

381

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

382

find_issues_with_query(query)

382

find_issues_with_query(query)

383

end

383

end

384

385

def test_operator_lesser_than_on_date_custom_field

385

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)

386

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')

387

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')

388

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

389

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

389

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

390

391

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

391

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

392

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

392

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

393

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

393

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

394

assert_include 1, issue_ids

394

assert_include 1, issue_ids

395

assert_not_include 2, issue_ids

395

assert_not_include 2, issue_ids

396

assert_not_include 3, issue_ids

396

assert_not_include 3, issue_ids

397

end

397

end

398

399

def test_operator_between

399

def test_operator_between

400

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

400

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

401

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

401

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

402

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

402

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

403

find_issues_with_query(query)

403

find_issues_with_query(query)

404

end

404

end

405

406

def test_operator_between_on_custom_field

406

def test_operator_between_on_custom_field

407

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

407

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

408

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

408

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

409

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

409

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

410

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

410

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

411

find_issues_with_query(query)

411

find_issues_with_query(query)

412

end

412

end

413

414

def test_date_filter_should_not_accept_non_date_values

414

def test_date_filter_should_not_accept_non_date_values

415

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

415

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

416

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

416

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

417

418

assert query.has_filter?('created_on')

418

assert query.has_filter?('created_on')

419

assert !query.valid?

419

assert !query.valid?

420

end

420

end

421

422

def test_date_filter_should_not_accept_invalid_date_values

422

def test_date_filter_should_not_accept_invalid_date_values

423

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

423

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

424

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

424

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

425

426

assert query.has_filter?('created_on')

426

assert query.has_filter?('created_on')

427

assert !query.valid?

427

assert !query.valid?

428

end

428

end

429

430

def test_relative_date_filter_should_not_accept_non_integer_values

430

def test_relative_date_filter_should_not_accept_non_integer_values

431

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

431

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

432

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

432

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

433

434

assert query.has_filter?('created_on')

434

assert query.has_filter?('created_on')

435

assert !query.valid?

435

assert !query.valid?

436

end

436

end

437

438

def test_operator_date_equals

438

def test_operator_date_equals

439

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

439

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

440

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

440

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

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

442

find_issues_with_query(query)

442

find_issues_with_query(query)

443

end

443

end

444

445

def test_operator_date_lesser_than

445

def test_operator_date_lesser_than

446

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

446

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

447

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

447

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

448

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

448

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

449

find_issues_with_query(query)

449

find_issues_with_query(query)

450

end

450

end

451

452

def test_operator_date_lesser_than_with_timestamp

452

def test_operator_date_lesser_than_with_timestamp

453

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

453

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

454

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

454

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

455

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

455

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

456

find_issues_with_query(query)

456

find_issues_with_query(query)

457

end

457

end

458

459

def test_operator_date_greater_than

459

def test_operator_date_greater_than

460

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

460

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

461

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

461

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

462

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

462

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

463

find_issues_with_query(query)

463

find_issues_with_query(query)

464

end

464

end

465

466

def test_operator_date_greater_than_with_timestamp

466

def test_operator_date_greater_than_with_timestamp

467

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

467

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

468

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

468

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

469

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

470

find_issues_with_query(query)

470

find_issues_with_query(query)

471

end

471

end

472

473

def test_operator_date_between

473

def test_operator_date_between

474

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

474

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

475

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

475

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

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

477

find_issues_with_query(query)

477

find_issues_with_query(query)

478

end

478

end

479

480

def test_operator_in_more_than

480

def test_operator_in_more_than

481

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

481

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

482

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

482

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

483

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

483

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

484

issues = find_issues_with_query(query)

484

issues = find_issues_with_query(query)

485

assert !issues.empty?

485

assert !issues.empty?

486

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

486

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

487

end

487

end

488

489

def test_operator_in_less_than

489

def test_operator_in_less_than

490

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

490

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

491

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

491

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

492

issues = find_issues_with_query(query)

492

issues = find_issues_with_query(query)

493

assert !issues.empty?

493

assert !issues.empty?

494

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

494

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

495

end

495

end

496

497

def test_operator_in_the_next_days

497

def test_operator_in_the_next_days

498

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

498

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

499

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

499

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

500

issues = find_issues_with_query(query)

500

issues = find_issues_with_query(query)

501

assert !issues.empty?

501

assert !issues.empty?

502

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

502

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

503

end

503

end

504

505

def test_operator_less_than_ago

505

def test_operator_less_than_ago

506

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

506

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

507

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

507

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

508

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

508

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

509

issues = find_issues_with_query(query)

509

issues = find_issues_with_query(query)

510

assert !issues.empty?

510

assert !issues.empty?

511

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

511

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

512

end

512

end

513

514

def test_operator_in_the_past_days

514

def test_operator_in_the_past_days

515

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

515

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

516

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

516

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

517

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

517

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

518

issues = find_issues_with_query(query)

518

issues = find_issues_with_query(query)

519

assert !issues.empty?

519

assert !issues.empty?

520

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

520

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

521

end

521

end

522

523

def test_operator_more_than_ago

523

def test_operator_more_than_ago

524

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

524

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

525

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

525

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

526

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

526

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

527

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

527

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

528

issues = find_issues_with_query(query)

528

issues = find_issues_with_query(query)

529

assert !issues.empty?

529

assert !issues.empty?

530

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

530

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

531

end

531

end

532

533

def test_operator_in

533

def test_operator_in

534

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

534

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

535

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

535

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

536

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

536

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

537

issues = find_issues_with_query(query)

537

issues = find_issues_with_query(query)

538

assert !issues.empty?

538

assert !issues.empty?

539

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

539

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

540

end

540

end

541

542

def test_operator_ago

542

def test_operator_ago

543

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

543

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

544

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

544

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

545

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

545

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

546

issues = find_issues_with_query(query)

546

issues = find_issues_with_query(query)

547

assert !issues.empty?

547

assert !issues.empty?

548

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

548

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

549

end

549

end

550

551

def test_operator_today

551

def test_operator_today

552

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

552

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

553

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

553

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

554

issues = find_issues_with_query(query)

554

issues = find_issues_with_query(query)

555

assert !issues.empty?

555

assert !issues.empty?

556

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

556

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

557

end

557

end

558

559

def test_operator_this_week_on_date

559

def test_operator_this_week_on_date

560

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

560

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

561

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

561

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

562

find_issues_with_query(query)

562

find_issues_with_query(query)

563

end

563

end

564

565

def test_operator_this_week_on_datetime

565

def test_operator_this_week_on_datetime

566

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

566

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

567

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

567

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

568

find_issues_with_query(query)

568

find_issues_with_query(query)

569

end

569

end

570

571

def test_operator_contains

571

def test_operator_contains

572

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

572

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

573

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

573

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

574

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

574

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

575

result = find_issues_with_query(query)

575

result = find_issues_with_query(query)

576

assert result.empty?

576

assert result.empty?

577

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

577

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

578

end

578

end

579

580

def test_range_for_this_week_with_week_starting_on_monday

580

def test_range_for_this_week_with_week_starting_on_monday

581

I18n.locale = :fr

581

I18n.locale = :fr

582

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

582

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

583

584

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

584

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

585

586

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

586

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

587

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

587

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

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

589

I18n.locale = :en

589

I18n.locale = :en

590

end

590

end

591

592

def test_range_for_this_week_with_week_starting_on_sunday

592

def test_range_for_this_week_with_week_starting_on_sunday

593

I18n.locale = :en

593

I18n.locale = :en

594

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

594

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

595

596

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

596

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

597

598

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

598

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

599

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

599

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

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

601

end

601

end

602

603

def test_operator_does_not_contains

603

def test_operator_does_not_contains

604

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

604

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

605

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

605

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

606

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

606

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

607

find_issues_with_query(query)

607

find_issues_with_query(query)

608

end

608

end

609

610

def test_filter_assigned_to_me

610

def test_filter_assigned_to_me

611

user = User.find(2)

611

user = User.find(2)

612

group = Group.find(10)

612

group = Group.find(10)

613

User.current = user

613

User.current = user

614

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

614

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)

615

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))

616

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

617

group.users << user

617

group.users << user

618

619

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

619

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

620

result = query.issues

620

result = query.issues

621

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

621

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

622

623

assert result.include?(i1)

623

assert result.include?(i1)

624

assert result.include?(i2)

624

assert result.include?(i2)

625

assert !result.include?(i3)

625

assert !result.include?(i3)

626

end

626

end

627

628

def test_user_custom_field_filtered_on_me

628

def test_user_custom_field_filtered_on_me

629

User.current = User.find(2)

629

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])

630

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)

631

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'})

632

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

633

634

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

634

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

635

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

635

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

636

assert_not_nil filter

636

assert_not_nil filter

637

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

637

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

638

639

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

639

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

640

result = query.issues

640

result = query.issues

641

assert_equal 1, result.size

641

assert_equal 1, result.size

642

assert_equal issue1, result.first

642

assert_equal issue1, result.first

643

end

643

end

644

645

def test_filter_my_projects

645

def test_filter_my_projects

646

User.current = User.find(2)

646

User.current = User.find(2)

647

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

647

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

648

filter = query.available_filters['project_id']

648

filter = query.available_filters['project_id']

649

assert_not_nil filter

649

assert_not_nil filter

650

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

650

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

651

652

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

652

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

653

result = query.issues

653

result = query.issues

654

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

654

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

655

end

655

end

656

657

def test_filter_watched_issues

657

def test_filter_watched_issues

658

User.current = User.find(1)

658

User.current = User.find(1)

659

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

659

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

660

result = find_issues_with_query(query)

660

result = find_issues_with_query(query)

661

assert_not_nil result

661

assert_not_nil result

662

assert !result.empty?

662

assert !result.empty?

663

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

663

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

664

User.current = nil

664

User.current = nil

665

end

665

end

666

667

def test_filter_unwatched_issues

667

def test_filter_unwatched_issues

668

User.current = User.find(1)

668

User.current = User.find(1)

669

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

669

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

670

result = find_issues_with_query(query)

670

result = find_issues_with_query(query)

671

assert_not_nil result

671

assert_not_nil result

672

assert !result.empty?

672

assert !result.empty?

673

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

673

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

674

User.current = nil

674

User.current = nil

675

end

675

end

676

677

def test_filter_on_custom_field_should_ignore_projects_with_field_disabled

677

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)

678

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'})

679

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'})

680

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

681

682

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

682

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

683

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

683

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

684

assert_equal 2, find_issues_with_query(query).size

684

assert_equal 2, find_issues_with_query(query).size

685

686

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

686

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

687

field.save!

687

field.save!

688

assert_equal 1, find_issues_with_query(query).size

688

assert_equal 1, find_issues_with_query(query).size

689

end

689

end

690

691

def test_filter_on_custom_field_should_ignore_trackers_with_field_disabled

691

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)

692

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'})

693

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'})

694

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

695

696

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

696

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

697

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

697

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

698

assert_equal 2, find_issues_with_query(query).size

698

assert_equal 2, find_issues_with_query(query).size

699

700

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

700

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

701

field.save!

701

field.save!

702

assert_equal 1, find_issues_with_query(query).size

702

assert_equal 1, find_issues_with_query(query).size

703

end

703

end

704

705

def test_filter_on_project_custom_field

705

def test_filter_on_project_custom_field

706

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

706

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

707

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

707

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

708

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

708

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

709

710

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

710

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

711

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

711

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

712

assert_include filter_name, query.available_filters.keys

712

assert_include filter_name, query.available_filters.keys

713

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

713

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

714

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

714

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

715

end

715

end

716

717

def test_filter_on_author_custom_field

717

def test_filter_on_author_custom_field

718

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

718

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

719

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

719

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

720

721

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

721

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

722

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

722

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

723

assert_include filter_name, query.available_filters.keys

723

assert_include filter_name, query.available_filters.keys

724

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

724

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

725

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

725

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

726

end

726

end

727

728

def test_filter_on_assigned_to_custom_field

728

def test_filter_on_assigned_to_custom_field

729

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

729

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

730

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

730

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

731

732

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

732

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

733

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

733

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

734

assert_include filter_name, query.available_filters.keys

734

assert_include filter_name, query.available_filters.keys

735

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

735

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

736

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

736

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

737

end

737

end

738

739

def test_filter_on_fixed_version_custom_field

739

def test_filter_on_fixed_version_custom_field

740

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

740

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

741

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

741

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

742

743

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

743

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

744

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

744

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

745

assert_include filter_name, query.available_filters.keys

745

assert_include filter_name, query.available_filters.keys

746

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

746

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

747

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

747

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

748

end

748

end

749

750

def test_filter_on_relations_with_a_specific_issue

750

def test_filter_on_relations_with_a_specific_issue

751

IssueRelation.delete_all

751

IssueRelation.delete_all

752

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

752

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))

753

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

754

755

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

755

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

756

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

756

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

757

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

757

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

758

759

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

759

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

760

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

760

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

761

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

761

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

762

end

762

end

763

764

def test_filter_on_relations_with_any_issues_in_a_project

764

def test_filter_on_relations_with_any_issues_in_a_project

765

IssueRelation.delete_all

765

IssueRelation.delete_all

766

with_settings :cross_project_issue_relations => '1' do

766

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)

767

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)

768

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)

769

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

770

end

770

end

771

772

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

772

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

773

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

773

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

774

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

774

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

775

776

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

776

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

777

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

777

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

778

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

778

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

779

780

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

780

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

781

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

781

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

782

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

782

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

783

end

783

end

784

785

def test_filter_on_relations_with_any_issues_not_in_a_project

785

def test_filter_on_relations_with_any_issues_not_in_a_project

786

IssueRelation.delete_all

786

IssueRelation.delete_all

787

with_settings :cross_project_issue_relations => '1' do

787

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)

788

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)

789

#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)

790

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

791

end

791

end

792

793

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

793

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

794

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

794

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

795

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

795

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

796

end

796

end

797

798

def test_filter_on_relations_with_no_issues_in_a_project

798

def test_filter_on_relations_with_no_issues_in_a_project

799

IssueRelation.delete_all

799

IssueRelation.delete_all

800

with_settings :cross_project_issue_relations => '1' do

800

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)

801

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)

802

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))

803

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

804

end

804

end

805

806

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

806

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

807

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

807

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

808

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

808

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

809

assert_include 2, ids

809

assert_include 2, ids

810

assert_not_include 1, ids

810

assert_not_include 1, ids

811

assert_not_include 3, ids

811

assert_not_include 3, ids

812

end

812

end

813

814

def test_filter_on_relations_with_no_issues

814

def test_filter_on_relations_with_no_issues

815

IssueRelation.delete_all

815

IssueRelation.delete_all

816

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

816

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))

817

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

818

819

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

819

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

820

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

820

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

821

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

821

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

822

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

822

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

823

assert_include 4, ids

823

assert_include 4, ids

824

end

824

end

825

826

def test_filter_on_relations_with_any_issues

826

def test_filter_on_relations_with_any_issues

827

IssueRelation.delete_all

827

IssueRelation.delete_all

828

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

828

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))

829

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

830

831

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

831

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

832

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

832

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

833

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

833

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

834

end

834

end

835

836

def test_filter_on_relations_should_not_ignore_other_filter

836

def test_filter_on_relations_should_not_ignore_other_filter

837

issue = Issue.generate!

837

issue = Issue.generate!

838

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

838

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

839

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

839

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

840

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

840

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

841

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

841

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

842

843

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

843

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

844

query.filters = {

844

query.filters = {

845

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

845

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

846

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

846

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

847

}

847

}

848

assert_equal [issue1], find_issues_with_query(query)

848

assert_equal [issue1], find_issues_with_query(query)

849

end

849

end

850

851

def test_statement_should_be_nil_with_no_filters

851

def test_statement_should_be_nil_with_no_filters

852

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

852

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

853

q.filters = {}

853

q.filters = {}

854

855

assert q.valid?

855

assert q.valid?

856

assert_nil q.statement

856

assert_nil q.statement

857

end

857

end

858

859

def test_default_columns

859

def test_default_columns

860

q = IssueQuery.new

860

q = IssueQuery.new

861

assert q.columns.any?

861

assert q.columns.any?

862

assert q.inline_columns.any?

862

assert q.inline_columns.any?

863

assert q.block_columns.empty?

863

assert q.block_columns.empty?

864

end

864

end

865

866

def test_set_column_names

866

def test_set_column_names

867

q = IssueQuery.new

867

q = IssueQuery.new

868

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

868

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

869

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

869

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

870

end

870

end

871

872

def test_has_column_should_accept_a_column_name

872

def test_has_column_should_accept_a_column_name

873

q = IssueQuery.new

873

q = IssueQuery.new

874

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

874

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

875

assert q.has_column?(:tracker)

875

assert q.has_column?(:tracker)

876

assert !q.has_column?(:category)

876

assert !q.has_column?(:category)

877

end

877

end

878

879

def test_has_column_should_accept_a_column

879

def test_has_column_should_accept_a_column

880

q = IssueQuery.new

880

q = IssueQuery.new

881

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

881

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

882

883

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

883

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

884

assert_kind_of QueryColumn, tracker_column

884

assert_kind_of QueryColumn, tracker_column

885

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

885

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

886

assert_kind_of QueryColumn, category_column

886

assert_kind_of QueryColumn, category_column

887

888

assert q.has_column?(tracker_column)

888

assert q.has_column?(tracker_column)

889

assert !q.has_column?(category_column)

889

assert !q.has_column?(category_column)

890

end

890

end

891

892

def test_inline_and_block_columns

892

def test_inline_and_block_columns

893

q = IssueQuery.new

893

q = IssueQuery.new

894

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

894

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

895

896

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

896

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

897

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

897

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

898

end

898

end

899

900

def test_custom_field_columns_should_be_inline

900

def test_custom_field_columns_should_be_inline

901

q = IssueQuery.new

901

q = IssueQuery.new

902

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

902

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

903

assert columns.any?

903

assert columns.any?

904

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

904

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

905

end

905

end

906

907

def test_query_should_preload_spent_hours

907

def test_query_should_preload_spent_hours

908

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

908

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

909

assert q.has_column?(:spent_hours)

909

assert q.has_column?(:spent_hours)

910

issues = q.issues

910

issues = q.issues

911

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

911

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

912

end

912

end

913

914

def test_groupable_columns_should_include_custom_fields

914

def test_groupable_columns_should_include_custom_fields

915

q = IssueQuery.new

915

q = IssueQuery.new

916

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

916

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

917

assert_not_nil column

917

assert_not_nil column

918

assert_kind_of QueryCustomFieldColumn, column

918

assert_kind_of QueryCustomFieldColumn, column

919

end

919

end

920

921

def test_groupable_columns_should_not_include_multi_custom_fields

921

def test_groupable_columns_should_not_include_multi_custom_fields

922

field = CustomField.find(1)

922

field = CustomField.find(1)

923

field.update_attribute :multiple, true

923

field.update_attribute :multiple, true

924

925

q = IssueQuery.new

925

q = IssueQuery.new

926

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

926

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

927

assert_nil column

927

assert_nil column

928

end

928

end

929

930

def test_groupable_columns_should_include_user_custom_fields

930

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')

931

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

932

933

q = IssueQuery.new

933

q = IssueQuery.new

934

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

934

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

935

end

935

end

936

937

def test_groupable_columns_should_include_version_custom_fields

937

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')

938

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

939

940

q = IssueQuery.new

940

q = IssueQuery.new

941

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

941

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

942

end

942

end

943

944

def test_grouped_with_valid_column

944

def test_grouped_with_valid_column

945

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

945

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

946

assert q.grouped?

946

assert q.grouped?

947

assert_not_nil q.group_by_column

947

assert_not_nil q.group_by_column

948

assert_equal :status, q.group_by_column.name

948

assert_equal :status, q.group_by_column.name

949

assert_not_nil q.group_by_statement

949

assert_not_nil q.group_by_statement

950

assert_equal 'status', q.group_by_statement

950

assert_equal 'status', q.group_by_statement

951

end

951

end

952

953

def test_grouped_with_invalid_column

953

def test_grouped_with_invalid_column

954

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

954

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

955

assert !q.grouped?

955

assert !q.grouped?

956

assert_nil q.group_by_column

956

assert_nil q.group_by_column

957

assert_nil q.group_by_statement

957

assert_nil q.group_by_statement

958

end

958

end

959

960

def test_sortable_columns_should_sort_assignees_according_to_user_format_setting

960

def test_sortable_columns_should_sort_assignees_according_to_user_format_setting

961

with_settings :user_format => 'lastname_coma_firstname' do

961

with_settings :user_format => 'lastname_coma_firstname' do

962

q = IssueQuery.new

962

q = IssueQuery.new

963

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

963

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

964

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

964

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

965

end

965

end

966

end

966

end

967

968

def test_sortable_columns_should_sort_authors_according_to_user_format_setting

968

def test_sortable_columns_should_sort_authors_according_to_user_format_setting

969

with_settings :user_format => 'lastname_coma_firstname' do

969

with_settings :user_format => 'lastname_coma_firstname' do

970

q = IssueQuery.new

970

q = IssueQuery.new

971

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

971

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

972

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

972

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

973

end

973

end

974

end

974

end

975

976

def test_sortable_columns_should_include_custom_field

976

def test_sortable_columns_should_include_custom_field

977

q = IssueQuery.new

977

q = IssueQuery.new

978

assert q.sortable_columns['cf_1']

978

assert q.sortable_columns['cf_1']

979

end

979

end

980

981

def test_sortable_columns_should_not_include_multi_custom_field

981

def test_sortable_columns_should_not_include_multi_custom_field

982

field = CustomField.find(1)

982

field = CustomField.find(1)

983

field.update_attribute :multiple, true

983

field.update_attribute :multiple, true

984

985

q = IssueQuery.new

985

q = IssueQuery.new

986

assert !q.sortable_columns['cf_1']

986

assert !q.sortable_columns['cf_1']

987

end

987

end

988

989

def test_default_sort

989

def test_default_sort

990

q = IssueQuery.new

990

q = IssueQuery.new

991

assert_equal [], q.sort_criteria

991

assert_equal [], q.sort_criteria

992

end

992

end

993

994

def test_set_sort_criteria_with_hash

994

def test_set_sort_criteria_with_hash

995

q = IssueQuery.new

995

q = IssueQuery.new

996

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

996

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

997

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

997

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

998

end

998

end

999

1000

def test_set_sort_criteria_with_array

1000

def test_set_sort_criteria_with_array

1001

q = IssueQuery.new

1001

q = IssueQuery.new

1002

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

1002

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

1003

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

1003

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

1004

end

1004

end

1005

1006

def test_create_query_with_sort

1006

def test_create_query_with_sort

1007

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

1007

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

1008

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

1008

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

1009

assert q.save

1009

assert q.save

1010

q.reload

1010

q.reload

1011

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

1011

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

1012

end

1012

end

1013

1014

def test_sort_by_string_custom_field_asc

1014

def test_sort_by_string_custom_field_asc

1015

q = IssueQuery.new

1015

q = IssueQuery.new

1016

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

1016

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

1017

assert c

1017

assert c

1018

assert c.sortable

1018

assert c.sortable

1019

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

1019

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

1020

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

1020

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

1021

assert !values.empty?

1021

assert !values.empty?

1022

assert_equal values.sort, values

1022

assert_equal values.sort, values

1023

end

1023

end

1024

1025

def test_sort_by_string_custom_field_desc

1025

def test_sort_by_string_custom_field_desc

1026

q = IssueQuery.new

1026

q = IssueQuery.new

1027

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

1027

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

1028

assert c

1028

assert c

1029

assert c.sortable

1029

assert c.sortable

1030

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

1030

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

1031

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

1031

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

1032

assert !values.empty?

1032

assert !values.empty?

1033

assert_equal values.sort.reverse, values

1033

assert_equal values.sort.reverse, values

1034

end

1034

end

1035

1036

def test_sort_by_float_custom_field_asc

1036

def test_sort_by_float_custom_field_asc

1037

q = IssueQuery.new

1037

q = IssueQuery.new

1038

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

1038

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

1039

assert c

1039

assert c

1040

assert c.sortable

1040

assert c.sortable

1041

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

1041

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

1042

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

1043

assert !values.empty?

1043

assert !values.empty?

1044

assert_equal values.sort, values

1044

assert_equal values.sort, values

1045

end

1045

end

1046

1047

def test_invalid_query_should_raise_query_statement_invalid_error

1047

def test_invalid_query_should_raise_query_statement_invalid_error

1048

q = IssueQuery.new

1048

q = IssueQuery.new

1049

assert_raise Query::StatementInvalid do

1049

assert_raise Query::StatementInvalid do

1050

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

1050

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

1051

end

1051

end

1052

end

1052

end

1053

1054

def test_issue_count

1054

def test_issue_count

1055

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

1055

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

1056

issue_count = q.issue_count

1056

issue_count = q.issue_count

1057

assert_equal q.issues.size, issue_count

1057

assert_equal q.issues.size, issue_count

1058

end

1058

end

1059

1060

def test_issue_count_with_archived_issues

1060

def test_issue_count_with_archived_issues

1061

p = Project.generate! do |project|

1061

p = Project.generate! do |project|

1062

project.status = Project::STATUS_ARCHIVED

1062

project.status = Project::STATUS_ARCHIVED

1063

end

1063

end

1064

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

1064

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

1065

assert !i.visible?

1065

assert !i.visible?

1066

1067

test_issue_count

1067

test_issue_count

1068

end

1068

end

1069

1070

def test_issue_count_by_association_group

1070

def test_issue_count_by_association_group

1071

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

1071

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

1072

count_by_group = q.issue_count_by_group

1072

count_by_group = q.issue_count_by_group

1073

assert_kind_of Hash, count_by_group

1073

assert_kind_of Hash, count_by_group

1074

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

1074

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

1075

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

1076

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

1076

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

1077

end

1077

end

1078

1079

def test_issue_count_by_list_custom_field_group

1079

def test_issue_count_by_list_custom_field_group

1080

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

1080

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

1081

count_by_group = q.issue_count_by_group

1081

count_by_group = q.issue_count_by_group

1082

assert_kind_of Hash, count_by_group

1082

assert_kind_of Hash, count_by_group

1083

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

1083

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

1084

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

1085

assert count_by_group.has_key?('MySQL')

1085

assert count_by_group.has_key?('MySQL')

1086

end

1086

end

1087

1088

def test_issue_count_by_date_custom_field_group

1088

def test_issue_count_by_date_custom_field_group

1089

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

1089

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

1090

count_by_group = q.issue_count_by_group

1090

count_by_group = q.issue_count_by_group

1091

assert_kind_of Hash, count_by_group

1091

assert_kind_of Hash, count_by_group

1092

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

1092

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

1093

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

1094

end

1094

end

1095

1096

def test_issue_count_with_nil_group_only

1096

def test_issue_count_with_nil_group_only

1097

Issue.update_all("assigned_to_id = NULL")

1097

Issue.update_all("assigned_to_id = NULL")

1098

1099

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

1099

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

1100

count_by_group = q.issue_count_by_group

1100

count_by_group = q.issue_count_by_group

1101

assert_kind_of Hash, count_by_group

1101

assert_kind_of Hash, count_by_group

1102

assert_equal 1, count_by_group.keys.size

1102

assert_equal 1, count_by_group.keys.size

1103

assert_nil count_by_group.keys.first

1103

assert_nil count_by_group.keys.first

1104

end

1104

end

1105

1106

def test_issue_ids

1106

def test_issue_ids

1107

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

1107

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

1108

order = "issues.subject, issues.id"

1108

order = "issues.subject, issues.id"

1109

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

1109

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

1110

assert_equal issues.map(&:id), q.issue_ids(:order => order)

1110

assert_equal issues.map(&:id), q.issue_ids(:order => order)

1111

end

1111

end

1112

1113

def test_label_for

1113

def test_label_for

1114

set_language_if_valid 'en'

1114

set_language_if_valid 'en'

1115

q = IssueQuery.new

1115

q = IssueQuery.new

1116

assert_equal 'Assignee', q.label_for('assigned_to_id')

1116

assert_equal 'Assignee', q.label_for('assigned_to_id')

1117

end

1117

end

1118

1119

def test_label_for_fr

1119

def test_label_for_fr

1120

set_language_if_valid 'fr'

1120

set_language_if_valid 'fr'

1121

q = IssueQuery.new

1121

q = IssueQuery.new

1122

assert_equal "Assign\xc3\xa9 \xc3\xa0".force_encoding('UTF-8'), q.label_for('assigned_to_id')

1122

assert_equal "Assign\xc3\xa9 \xc3\xa0".force_encoding('UTF-8'), q.label_for('assigned_to_id')

1123

end

1123

end

1124

1125

def test_editable_by

1125

def test_editable_by

1126

admin = User.find(1)

1126

admin = User.find(1)

1127

manager = User.find(2)

1127

manager = User.find(2)

1128

developer = User.find(3)

1128

developer = User.find(3)

1129

1130

# Public query on project 1

1130

# Public query on project 1

1131

q = IssueQuery.find(1)

1131

q = IssueQuery.find(1)

1132

assert q.editable_by?(admin)

1132

assert q.editable_by?(admin)

1133

assert q.editable_by?(manager)

1133

assert q.editable_by?(manager)

1134

assert !q.editable_by?(developer)

1134

assert !q.editable_by?(developer)

1135

1136

# Private query on project 1

1136

# Private query on project 1

1137

q = IssueQuery.find(2)

1137

q = IssueQuery.find(2)

1138

assert q.editable_by?(admin)

1138

assert q.editable_by?(admin)

1139

assert !q.editable_by?(manager)

1139

assert !q.editable_by?(manager)

1140

assert q.editable_by?(developer)

1140

assert q.editable_by?(developer)

1141

1142

# Private query for all projects

1142

# Private query for all projects

1143

q = IssueQuery.find(3)

1143

q = IssueQuery.find(3)

1144

assert q.editable_by?(admin)

1144

assert q.editable_by?(admin)

1145

assert !q.editable_by?(manager)

1145

assert !q.editable_by?(manager)

1146

assert q.editable_by?(developer)

1146

assert q.editable_by?(developer)

1147

1148

# Public query for all projects

1148

# Public query for all projects

1149

q = IssueQuery.find(4)

1149

q = IssueQuery.find(4)

1150

assert q.editable_by?(admin)

1150

assert q.editable_by?(admin)

1151

assert !q.editable_by?(manager)

1151

assert !q.editable_by?(manager)

1152

assert !q.editable_by?(developer)

1152

assert !q.editable_by?(developer)

1153

end

1153

end

1154

1155

def test_visible_scope

1155

def test_visible_scope

1156

query_ids = IssueQuery.visible(User.anonymous).map(&:id)

1156

query_ids = IssueQuery.visible(User.anonymous).map(&:id)

1157

1158

assert query_ids.include?(1), 'public query on public project was not visible'

1158

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'

1159

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'

1160

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'

1161

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'

1162

assert !query_ids.include?(7), 'public query on private project was visible'

1163

end

1163

end

1164

1165

def test_query_with_public_visibility_should_be_visible_to_anyone

1165

def test_query_with_public_visibility_should_be_visible_to_anyone

1166

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)

1166

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PUBLIC)

1167

1168

assert q.visible?(User.anonymous)

1168

assert q.visible?(User.anonymous)

1169

assert IssueQuery.visible(User.anonymous).find_by_id(q.id)

1169

assert IssueQuery.visible(User.anonymous).find_by_id(q.id)

1170

1171

assert q.visible?(User.find(7))

1171

assert q.visible?(User.find(7))

1172

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1172

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1173

1174

assert q.visible?(User.find(2))

1174

assert q.visible?(User.find(2))

1175

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1175

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1176

1177

assert q.visible?(User.find(1))

1177

assert q.visible?(User.find(1))

1178

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1178

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1179

end

1179

end

1180

1181

def test_query_with_roles_visibility_should_be_visible_to_user_with_role

1181

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])

1182

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

1183

1184

assert !q.visible?(User.anonymous)

1184

assert !q.visible?(User.anonymous)

1185

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1185

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1186

1187

assert !q.visible?(User.find(7))

1187

assert !q.visible?(User.find(7))

1188

assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)

1188

assert_nil IssueQuery.visible(User.find(7)).find_by_id(q.id)

1189

1190

assert q.visible?(User.find(2))

1190

assert q.visible?(User.find(2))

1191

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1191

assert IssueQuery.visible(User.find(2)).find_by_id(q.id)

1192

1193

assert q.visible?(User.find(1))

1193

assert q.visible?(User.find(1))

1194

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1194

assert IssueQuery.visible(User.find(1)).find_by_id(q.id)

1195

end

1195

end

1196

1197

def test_query_with_private_visibility_should_be_visible_to_owner

1197

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))

1198

q = IssueQuery.create!(:name => 'Query', :visibility => IssueQuery::VISIBILITY_PRIVATE, :user => User.find(7))

1199

1200

assert !q.visible?(User.anonymous)

1200

assert !q.visible?(User.anonymous)

1201

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1201

assert_nil IssueQuery.visible(User.anonymous).find_by_id(q.id)

1202

1203

assert q.visible?(User.find(7))

1203

assert q.visible?(User.find(7))

1204

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1204

assert IssueQuery.visible(User.find(7)).find_by_id(q.id)

1205

1206

assert !q.visible?(User.find(2))

1206

assert !q.visible?(User.find(2))

1207

assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)

1207

assert_nil IssueQuery.visible(User.find(2)).find_by_id(q.id)

1208

1209

assert q.visible?(User.find(1))

1209

assert q.visible?(User.find(1))

1210

assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)

1210

assert_nil IssueQuery.visible(User.find(1)).find_by_id(q.id)

1211

end

1211

end

1212

1213

test "#available_filters should include users of visible projects in cross-project view" do

1213

test "#available_filters should include users of visible projects in cross-project view" do

1214

users = IssueQuery.new.available_filters["assigned_to_id"]

1214

users = IssueQuery.new.available_filters["assigned_to_id"]

1215

assert_not_nil users

1215

assert_not_nil users

1216

assert users[:values].map{|u|u[1]}.include?("3")

1216

assert users[:values].map{|u|u[1]}.include?("3")

1217

end

1217

end

1218

1219

test "#available_filters should include users of subprojects" do

1219

test "#available_filters should include users of subprojects" do

1220

user1 = User.generate!

1220

user1 = User.generate!

1221

user2 = User.generate!

1221

user2 = User.generate!

1222

project = Project.find(1)

1222

project = Project.find(1)

1223

Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])

1223

Member.create!(:principal => user1, :project => project.children.visible.first, :role_ids => [1])

1224

1225

users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]

1225

users = IssueQuery.new(:project => project).available_filters["assigned_to_id"]

1226

assert_not_nil users

1226

assert_not_nil users

1227

assert users[:values].map{|u|u[1]}.include?(user1.id.to_s)

1227

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)

1228

assert !users[:values].map{|u|u[1]}.include?(user2.id.to_s)

1229

end

1229

end

1230

1231

test "#available_filters should include visible projects in cross-project view" do

1231

test "#available_filters should include visible projects in cross-project view" do

1232

projects = IssueQuery.new.available_filters["project_id"]

1232

projects = IssueQuery.new.available_filters["project_id"]

1233

assert_not_nil projects

1233

assert_not_nil projects

1234

assert projects[:values].map{|u|u[1]}.include?("1")

1234

assert projects[:values].map{|u|u[1]}.include?("1")

1235

end

1235

end

1236

1237

test "#available_filters should include 'member_of_group' filter" do

1237

test "#available_filters should include 'member_of_group' filter" do

1238

query = IssueQuery.new

1238

query = IssueQuery.new

1239

assert query.available_filters.keys.include?("member_of_group")

1239

assert query.available_filters.keys.include?("member_of_group")

1240

assert_equal :list_optional, query.available_filters["member_of_group"][:type]

1240

assert_equal :list_optional, query.available_filters["member_of_group"][:type]

1241

assert query.available_filters["member_of_group"][:values].present?

1241

assert query.available_filters["member_of_group"][:values].present?

1242

assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},

1242

assert_equal Group.givable.sort.map {|g| [g.name, g.id.to_s]},

1243

query.available_filters["member_of_group"][:values].sort

1243

query.available_filters["member_of_group"][:values].sort

1244

end

1244

end

1245

1246

test "#available_filters should include 'assigned_to_role' filter" do

1246

test "#available_filters should include 'assigned_to_role' filter" do

1247

query = IssueQuery.new

1247

query = IssueQuery.new

1248

assert query.available_filters.keys.include?("assigned_to_role")

1248

assert query.available_filters.keys.include?("assigned_to_role")

1249

assert_equal :list_optional, query.available_filters["assigned_to_role"][:type]

1249

assert_equal :list_optional, query.available_filters["assigned_to_role"][:type]

1250

1251

assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])

1251

assert query.available_filters["assigned_to_role"][:values].include?(['Manager','1'])

1252

assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])

1252

assert query.available_filters["assigned_to_role"][:values].include?(['Developer','2'])

1253

assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])

1253

assert query.available_filters["assigned_to_role"][:values].include?(['Reporter','3'])

1254

1255

assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])

1255

assert ! query.available_filters["assigned_to_role"][:values].include?(['Non member','4'])

1256

assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])

1256

assert ! query.available_filters["assigned_to_role"][:values].include?(['Anonymous','5'])

1257

end

1257

end

1258

1259

def test_available_filters_should_include_custom_field_according_to_user_visibility

1259

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)

1260

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])

1261

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1262

1263

with_current_user User.find(3) do

1263

with_current_user User.find(3) do

1264

query = IssueQuery.new

1264

query = IssueQuery.new

1265

assert_include "cf_#{visible_field.id}", query.available_filters.keys

1265

assert_include "cf_#{visible_field.id}", query.available_filters.keys

1266

assert_not_include "cf_#{hidden_field.id}", query.available_filters.keys

1266

assert_not_include "cf_#{hidden_field.id}", query.available_filters.keys

1267

end

1267

end

1268

end

1268

end

1269

1270

def test_available_columns_should_include_custom_field_according_to_user_visibility

1270

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)

1271

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])

1272

hidden_field = IssueCustomField.generate!(:is_for_all => true, :is_filter => true, :visible => false, :role_ids => [1])

1273

1274

with_current_user User.find(3) do

1274

with_current_user User.find(3) do

1275

query = IssueQuery.new

1275

query = IssueQuery.new

1276

assert_include :"cf_#{visible_field.id}", query.available_columns.map(&:name)

1276

assert_include :"cf_#{visible_field.id}", query.available_columns.map(&:name)

1277

assert_not_include :"cf_#{hidden_field.id}", query.available_columns.map(&:name)

1277

assert_not_include :"cf_#{hidden_field.id}", query.available_columns.map(&:name)

1278

end

1278

end

1279

end

1279

end

1280

1281

context "#statement" do

1281

context "#statement" do

1282

context "with 'member_of_group' filter" do

1282

context "with 'member_of_group' filter" do

1283

setup do

1283

setup do

1284

Group.destroy_all # No fixtures

1284

Group.destroy_all # No fixtures

1285

@user_in_group = User.generate!

1285

@user_in_group = User.generate!

1286

@second_user_in_group = User.generate!

1286

@second_user_in_group = User.generate!

1287

@user_in_group2 = User.generate!

1287

@user_in_group2 = User.generate!

1288

@user_not_in_group = User.generate!

1288

@user_not_in_group = User.generate!

1289

1290

@group = Group.generate!.reload

1290

@group = Group.generate!.reload

1291

@group.users << @user_in_group

1291

@group.users << @user_in_group

1292

@group.users << @second_user_in_group

1292

@group.users << @second_user_in_group

1293

1294

@group2 = Group.generate!.reload

1294

@group2 = Group.generate!.reload

1295

@group2.users << @user_in_group2

1295

@group2.users << @user_in_group2

1296

1297

end

1297

end

1298

1299

should "search assigned to for users in the group" do

1299

should "search assigned to for users in the group" do

1300

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

1300

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

1301

@query.add_filter('member_of_group', '=', [@group.id.to_s])

1301

@query.add_filter('member_of_group', '=', [@group.id.to_s])

1302

1303

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_query_statement_includes @query, "#{Issue.table_name}.assigned_to_id IN ('#{@user_in_group.id}','#{@second_user_in_group.id}','#{@group.id}')"

1304

assert_find_issues_with_query_is_successful @query

1304

assert_find_issues_with_query_is_successful @query

1305

end

1305

end

1306

1307

should "search not assigned to any group member (none)" do

1307

should "search not assigned to any group member (none)" do

1308

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

1308

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

1309

@query.add_filter('member_of_group', '!*', [''])

1309

@query.add_filter('member_of_group', '!*', [''])

1310

1311

# Users not in a group

1311

# Users not in a group

1312

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_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}')"

1313

assert_find_issues_with_query_is_successful @query

1313

assert_find_issues_with_query_is_successful @query

1314

end

1314

end

1315

1316

should "search assigned to any group member (all)" do

1316

should "search assigned to any group member (all)" do

1317

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

1317

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

1318

@query.add_filter('member_of_group', '*', [''])

1318

@query.add_filter('member_of_group', '*', [''])

1319

1320

# Only users in a group

1320

# Only users in a group

1321

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_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}')"

1322

assert_find_issues_with_query_is_successful @query

1322

assert_find_issues_with_query_is_successful @query

1323

end

1323

end

1324

1325

should "return an empty set with = empty group" do

1325

should "return an empty set with = empty group" do

1326

@empty_group = Group.generate!

1326

@empty_group = Group.generate!

1327

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

1327

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

1328

@query.add_filter('member_of_group', '=', [@empty_group.id.to_s])

1328

@query.add_filter('member_of_group', '=', [@empty_group.id.to_s])

1329

1330

assert_equal [], find_issues_with_query(@query)

1330

assert_equal [], find_issues_with_query(@query)

1331

end

1331

end

1332

1333

should "return issues with ! empty group" do

1333

should "return issues with ! empty group" do

1334

@empty_group = Group.generate!

1334

@empty_group = Group.generate!

1335

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

1335

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

1336

@query.add_filter('member_of_group', '!', [@empty_group.id.to_s])

1336

@query.add_filter('member_of_group', '!', [@empty_group.id.to_s])

1337

1338

assert_find_issues_with_query_is_successful @query

1338

assert_find_issues_with_query_is_successful @query

1339

end

1339

end

1340

end

1340

end

1341

1342

context "with 'assigned_to_role' filter" do

1342

context "with 'assigned_to_role' filter" do

1343

setup do

1343

setup do

1344

@manager_role = Role.find_by_name('Manager')

1344

@manager_role = Role.find_by_name('Manager')

1345

@developer_role = Role.find_by_name('Developer')

1345

@developer_role = Role.find_by_name('Developer')

1346

1347

@project = Project.generate!

1347

@project = Project.generate!

1348

@manager = User.generate!

1348

@manager = User.generate!

1349

@developer = User.generate!

1349

@developer = User.generate!

1350

@boss = User.generate!

1350

@boss = User.generate!

1351

@guest = User.generate!

1351

@guest = User.generate!

1352

User.add_to_project(@manager, @project, @manager_role)

1352

User.add_to_project(@manager, @project, @manager_role)

1353

User.add_to_project(@developer, @project, @developer_role)

1353

User.add_to_project(@developer, @project, @developer_role)

1354

User.add_to_project(@boss, @project, [@manager_role, @developer_role])

1354

User.add_to_project(@boss, @project, [@manager_role, @developer_role])

1355

1356

@issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)

1356

@issue1 = Issue.generate!(:project => @project, :assigned_to_id => @manager.id)

1357

@issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)

1357

@issue2 = Issue.generate!(:project => @project, :assigned_to_id => @developer.id)

1358

@issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)

1358

@issue3 = Issue.generate!(:project => @project, :assigned_to_id => @boss.id)

1359

@issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)

1359

@issue4 = Issue.generate!(:project => @project, :assigned_to_id => @guest.id)

1360

@issue5 = Issue.generate!(:project => @project)

1360

@issue5 = Issue.generate!(:project => @project)

1361

end

1361

end

1362

1363

should "search assigned to for users with the Role" do

1363

should "search assigned to for users with the Role" do

1364

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

1364

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

1365

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1365

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1366

1367

assert_query_result [@issue1, @issue3], @query

1367

assert_query_result [@issue1, @issue3], @query

1368

end

1368

end

1369

1370

should "search assigned to for users with the Role on the issue project" do

1370

should "search assigned to for users with the Role on the issue project" do

1371

other_project = Project.generate!

1371

other_project = Project.generate!

1372

User.add_to_project(@developer, other_project, @manager_role)

1372

User.add_to_project(@developer, other_project, @manager_role)

1373

1374

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

1374

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

1375

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1375

@query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])

1376

1377

assert_query_result [@issue1, @issue3], @query

1377

assert_query_result [@issue1, @issue3], @query

1378

end

1378

end

1379

1380

should "return an empty set with empty role" do

1380

should "return an empty set with empty role" do

1381

@empty_role = Role.generate!

1381

@empty_role = Role.generate!

1382

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

1382

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

1383

@query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])

1383

@query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])

1384

1385

assert_query_result [], @query

1385

assert_query_result [], @query

1386

end

1386

end

1387

1388

should "search assigned to for users without the Role" do

1388

should "search assigned to for users without the Role" do

1389

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

1389

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

1390

@query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])

1390

@query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])

1391

1392

assert_query_result [@issue2, @issue4, @issue5], @query

1392

assert_query_result [@issue2, @issue4, @issue5], @query

1393

end

1393

end

1394

1395

should "search assigned to for users not assigned to any Role (none)" do

1395

should "search assigned to for users not assigned to any Role (none)" do

1396

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

1396

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

1397

@query.add_filter('assigned_to_role', '!*', [''])

1397

@query.add_filter('assigned_to_role', '!*', [''])

1398

1399

assert_query_result [@issue4, @issue5], @query

1399

assert_query_result [@issue4, @issue5], @query

1400

end

1400

end

1401

1402

should "search assigned to for users assigned to any Role (all)" do

1402

should "search assigned to for users assigned to any Role (all)" do

1403

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

1403

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

1404

@query.add_filter('assigned_to_role', '*', [''])

1404

@query.add_filter('assigned_to_role', '*', [''])

1405

1406

assert_query_result [@issue1, @issue2, @issue3], @query

1406

assert_query_result [@issue1, @issue2, @issue3], @query

1407

end

1407

end

1408

1409

should "return issues with ! empty role" do

1409

should "return issues with ! empty role" do

1410

@empty_role = Role.generate!

1410

@empty_role = Role.generate!

1411

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

1411

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

1412

@query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])

1412

@query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])

1413

1414

assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query

1414

assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query

1415

end

1415

end

1416

end

1416

end

1417

end

1417

end

1418

1419

def test_query_column_should_accept_a_symbol_as_caption

1420

c = QueryColumn.new('foo', :caption => :general_text_Yes)

1421

assert_equal 'Yes', c.caption

1422

end

1423

1424

def test_query_column_should_accept_a_proc_as_caption

1425

c = QueryColumn.new('foo', :caption => lambda {'Foo'})

1426

assert_equal 'Foo', c.caption

1427

end

1418

end

1428

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.
             class QueryColumn
               attr_accessor :name, :sortable, :groupable, :default_order
               include Redmine::I18n
               def initialize(name, options={})
                 self.name = name
                 self.sortable = options[:sortable]
                 self.groupable = options[:groupable] || false
                 if groupable == true
                   self.groupable = name.to_s
                 end
                 self.default_order = options[:default_order]
                 @inline = options.key?(:inline) ? options[:inline] : true
                 @caption_key = options[:caption] || "field_#{name}".to_sym
                 @frozen = options[:frozen]
               end
               def caption
-                @caption_key.is_a?(Symbol) ? l(@caption_key) : @caption_key
+                case @caption_key
+                when Symbol
+                  l(@caption_key)
+                when Proc
+                  @caption_key.call
+                else
+                  @caption_key
+                end
               end
               # Returns true if the column is sortable, otherwise false
               def sortable?
                 !@sortable.nil?
               end
               def sortable
                 @sortable.is_a?(Proc) ? @sortable.call : @sortable
               end
               def inline?
                 @inline
               end
               def frozen?
                 @frozen
               end
               def value(object)
                 object.send name
               end
               def value_object(object)
                 object.send name
               end
               def css_classes
                 name
               end
             end
             class QueryCustomFieldColumn < QueryColumn
               def initialize(custom_field)
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 self.groupable = custom_field.group_statement || false
                 @inline = true
                 @cf = custom_field
               end
               def caption
                 @cf.name
               end
               def custom_field
                 @cf
               end
               def value_object(object)
                 if custom_field.visible_by?(object.project, User.current)
                   cv = object.custom_values.select {|v| v.custom_field_id == @cf.id}
                   cv.size > 1 ? cv.sort {|a,b| a.value.to_s <=> b.value.to_s} : cv.first
                 else
                   nil
                 end
               end
               def value(object)
                 raw = value_object(object)
                 if raw.is_a?(Array)
                   raw.map {|r| @cf.cast_value(r.value)}
                 elsif raw
                   @cf.cast_value(raw.value)
                 else
                   nil
                 end
               end
               def css_classes
                 @css_classes ||= "#{name} #{@cf.field_format}"
               end
             end
             class QueryAssociationCustomFieldColumn < QueryCustomFieldColumn
               def initialize(association, custom_field)
                 super(custom_field)
                 self.name = "#{association}.cf_#{custom_field.id}".to_sym
                 # TODO: support sorting/grouping by association custom field
                 self.sortable = false
                 self.groupable = false
                 @association = association
               end
               def value_object(object)
                 if assoc = object.send(@association)
                   super(assoc)
                 end
               end
               def css_classes
                 @css_classes ||= "#{@association}_cf_#{@cf.id} #{@cf.field_format}"
               end
             end
             class Query < ActiveRecord::Base
               class StatementInvalid < ::ActiveRecord::StatementInvalid
               end
               VISIBILITY_PRIVATE = 0
               VISIBILITY_ROLES   = 1
               VISIBILITY_PUBLIC  = 2
               belongs_to :project
               belongs_to :user
               has_and_belongs_to_many :roles, :join_table => "#{table_name_prefix}queries_roles#{table_name_suffix}", :foreign_key => "query_id"
               serialize :filters
               serialize :column_names
               serialize :sort_criteria, Array
               serialize :options, Hash
               attr_protected :project_id, :user_id
               validates_presence_of :name
               validates_length_of :name, :maximum => 255
               validates :visibility, :inclusion => { :in => [VISIBILITY_PUBLIC, VISIBILITY_ROLES, VISIBILITY_PRIVATE] }
               validate :validate_query_filters
               validate do |query|
                 errors.add(:base, l(:label_role_plural) + ' ' + l('activerecord.errors.messages.blank')) if query.visibility == VISIBILITY_ROLES && roles.blank?
               end
               after_save do |query|
                 if query.visibility_changed? && query.visibility != VISIBILITY_ROLES
                   query.roles.clear
                 end
               end
               class_attribute :operators
               self.operators = {
                 "="   => :label_equals,
                 "!"   => :label_not_equals,
                 "o"   => :label_open_issues,
                 "c"   => :label_closed_issues,
                 "!*"  => :label_none,
                 "*"   => :label_any,
                 ">="  => :label_greater_or_equal,
                 "<="  => :label_less_or_equal,
                 "><"  => :label_between,
                 "<t+" => :label_in_less_than,
                 ">t+" => :label_in_more_than,
                 "><t+"=> :label_in_the_next_days,
                 "t+"  => :label_in,
                 "t"   => :label_today,
                 "ld"  => :label_yesterday,
                 "w"   => :label_this_week,
                 "lw"  => :label_last_week,
                 "l2w" => [:label_last_n_weeks, {:count => 2}],
                 "m"   => :label_this_month,
                 "lm"  => :label_last_month,
                 "y"   => :label_this_year,
                 ">t-" => :label_less_than_ago,
                 "<t-" => :label_more_than_ago,
                 "><t-"=> :label_in_the_past_days,
                 "t-"  => :label_ago,
                 "~"   => :label_contains,
                 "!~"  => :label_not_contains,
                 "=p"  => :label_any_issues_in_project,
                 "=!p" => :label_any_issues_not_in_project,
                 "!p"  => :label_no_issues_in_project
               }
               class_attribute :operators_by_filter_type
               self.operators_by_filter_type = {
                 :list => [ "=", "!" ],
                 :list_status => [ "o", "=", "!", "c", "*" ],
                 :list_optional => [ "=", "!", "!*", "*" ],
                 :list_subprojects => [ "*", "!*", "=" ],
                 :date => [ "=", ">=", "<=", "><", "<t+", ">t+", "><t+", "t+", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", ">t-", "<t-", "><t-", "t-", "!*", "*" ],
                 :date_past => [ "=", ">=", "<=", "><", ">t-", "<t-", "><t-", "t-", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", "!*", "*" ],
                 :string => [ "=", "~", "!", "!~", "!*", "*" ],
                 :text => [  "~", "!~", "!*", "*" ],
                 :integer => [ "=", ">=", "<=", "><", "!*", "*" ],
                 :float => [ "=", ">=", "<=", "><", "!*", "*" ],
                 :relation => ["=", "=p", "=!p", "!p", "!*", "*"]
               }
               class_attribute :available_columns
               self.available_columns = []
               class_attribute :queried_class
               def queried_table_name
                 @queried_table_name ||= self.class.queried_class.table_name
               end
               def initialize(attributes=nil, *args)
                 super attributes
                 @is_for_all = project.nil?
               end
               # Builds the query from the given params
               def build_from_params(params)
                 if params[:fields] || params[:f]
                   self.filters = {}
                   add_filters(params[:fields] || params[:f], params[:operators] || params[:op], params[:values] || params[:v])
                 else
                   available_filters.keys.each do |field|
                     add_short_filter(field, params[field]) if params[field]
                   end
                 end
                 self.group_by = params[:group_by] || (params[:query] && params[:query][:group_by])
                 self.column_names = params[:c] || (params[:query] && params[:query][:column_names])
                 self
               end
               # Builds a new query from the given params and attributes
               def self.build_from_params(params, attributes={})
                 new(attributes).build_from_params(params)
               end
               def validate_query_filters
                 filters.each_key do |field|
                   if values_for(field)
                     case type_for(field)
                     when :integer
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+$/) }
                     when :float
                       add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^[+-]?\d+(\.\d*)?$/) }
                     when :date, :date_past
                       case operator_for(field)
                       when "=", ">=", "<=", "><"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v|
                           v.present? && (!v.match(/\A\d{4}-\d{2}-\d{2}(T\d{2}((:)?\d{2}){0,2}(Z|\d{2}:?\d{2})?)?\z/) || parse_date(v).nil?)
                         }
                       when ">t-", "<t-", "t-", ">t+", "<t+", "t+", "><t+", "><t-"
                         add_filter_error(field, :invalid) if values_for(field).detect {|v| v.present? && !v.match(/^\d+$/) }
                       end
                     end
                   end
                   add_filter_error(field, :blank) unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t", "ld", "w", "lw", "l2w", "m", "lm", "y"].include? operator_for(field)
                 end if filters
               end
               def add_filter_error(field, message)
                 m = label_for(field) + " " + l(message, :scope => 'activerecord.errors.messages')
                 errors.add(:base, m)
               end
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
                 return true if user.admin? || (is_private? && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
                 is_public? && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def trackers
                 @trackers ||= project.nil? ? Tracker.sorted.to_a : project.rolled_up_trackers
               end
               # Returns a hash of localized labels for all filter operators
               def self.operators_labels
                 operators.inject({}) {|h, operator| h[operator.first] = l(*operator.last); h}
               end
               # Returns a representation of the available filters for JSON serialization
               def available_filters_as_json
                 json = {}
                 available_filters.each do |field, options|
                   json[field] = options.slice(:type, :name, :values).stringify_keys
                 end
                 json
               end
               def all_projects
                 @all_projects ||= Project.visible.to_a
               end
               def all_projects_values
                 return @all_projects_values if @all_projects_values
                 values = []
                 Project.project_tree(all_projects) do |p, level|
                   prefix = (level > 0 ? ('--' * level + ' ') : '')
                   values << ["#{prefix}#{p.name}", p.id.to_s]
                 end
                 @all_projects_values = values
               end
               # Adds available filters
               def initialize_available_filters
                 # implemented by sub-classes
               end
               protected :initialize_available_filters
               # Adds an available filter
               def add_available_filter(field, options)
                 @available_filters ||= ActiveSupport::OrderedHash.new
                 @available_filters[field] = options
                 @available_filters
               end
               # Removes an available filter
               def delete_available_filter(field)
                 if @available_filters
                   @available_filters.delete(field)
                 end
               end
               # Return a hash of available filters
               def available_filters
                 unless @available_filters
                   initialize_available_filters
                   @available_filters.each do |field, options|
                     options[:name] ||= l(options[:label] || "field_#{field}".gsub(/_id$/, ''))
                   end
                 end
                 @available_filters
               end
               def add_filter(field, operator, values=nil)
                 # values must be an array
                 return unless values.nil? || values.is_a?(Array)
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   filters[field] = {:operator => operator, :values => (values || [''])}
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression && available_filters.has_key?(field)
                 field_type = available_filters[field][:type]
                 operators_by_filter_type[field_type].sort.reverse.detect do |operator|
                   next unless expression =~ /^#{Regexp.escape(operator)}(.*)$/
                   values = $1
                   add_filter field, operator, values.present? ? values.split('|') : ['']
                 end || add_filter(field, '=', expression.split('|'))
               end
               # Add multiple filters using +add_filter+
               def add_filters(fields, operators, values)
                 if fields.is_a?(Array) && operators.is_a?(Hash) && (values.nil? || values.is_a?(Hash))
                   fields.each do |field|
                     add_filter(field, operators[field], values && values[field])
                   end
                 end
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def type_for(field)
                 available_filters[field][:type] if available_filters.has_key?(field)
               end
               def operator_for(field)
                 has_filter?(field) ? filters[field][:operator] : nil
               end
               def values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def value_for(field, index=0)
                 (values_for(field) || [])[index]
               end
               def label_for(field)
                 label = available_filters[field][:name] if available_filters.has_key?(field)
                 label ||= l("field_#{field.to_s.gsub(/_id$/, '')}", :default => field)
               end
               def self.add_available_column(column)
                 self.available_columns << (column) if column.is_a?(QueryColumn)
               end
               # Returns an array of columns that can be used to group the results
               def groupable_columns
                 available_columns.select {|c| c.groupable}
               end
               # Returns a Hash of columns and the key for sorting
               def sortable_columns
                 available_columns.inject({}) {|h, column|
                   h[column.name.to_s] = column.sortable
                   h
                 }
               end
               def columns
                 # preserve the column_names order
                 cols = (has_default_columns? ? default_columns_names : column_names).collect do |name|
                    available_columns.find { |col| col.name == name }
                 end.compact
                 available_columns.select(&:frozen?) | cols
               end
               def inline_columns
                 columns.select(&:inline?)
               end
               def block_columns
                 columns.reject(&:inline?)
               end
               def available_inline_columns
                 available_columns.select(&:inline?)
               end
               def available_block_columns
                 available_columns.reject(&:inline?)
               end
               def default_columns_names
                 []
               end
               def column_names=(names)
                 if names
                   names = names.select {|n| n.is_a?(Symbol) || !n.blank? }
                   names = names.collect {|n| n.is_a?(Symbol) ? n : n.to_sym }
                   # Set column_names to nil if default columns
                   if names == default_columns_names
                     names = nil
                   end
                 end
                 write_attribute(:column_names, names)
               end
               def has_column?(column)
                 column_names && column_names.include?(column.is_a?(QueryColumn) ? column.name : column)
               end
               def has_custom_field_column?
                 columns.any? {|column| column.is_a? QueryCustomFieldColumn}
               end
               def has_default_columns?
                 column_names.nil? || column_names.empty?
               end
               def sort_criteria=(arg)
                 c = []
                 if arg.is_a?(Hash)
                   arg = arg.keys.sort.collect {|k| arg[k]}
                 end
                 c = arg.select {|k,o| !k.to_s.blank?}.slice(0,3).collect {|k,o| [k.to_s, (o == 'desc' || o == false) ? 'desc' : 'asc']}
                 write_attribute(:sort_criteria, c)
               end
               def sort_criteria
                 read_attribute(:sort_criteria) || []
               end
               def sort_criteria_key(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].first
               end
               def sort_criteria_order(arg)
                 sort_criteria && sort_criteria[arg] && sort_criteria[arg].last
               end
               def sort_criteria_order_for(key)
                 sort_criteria.detect {|k, order| key.to_s == k}.try(:last)
               end
               # Returns the SQL sort order that should be prepended for grouping
               def group_by_sort_order
                 if grouped? && (column = group_by_column)
                   order = sort_criteria_order_for(column.name) || column.default_order
                   column.sortable.is_a?(Array) ?
                     column.sortable.collect {|s| "#{s} #{order}"}.join(',') :
                     "#{column.sortable} #{order}"
                 end
               end
               # Returns true if the query is a grouped query
               def grouped?
                 !group_by_column.nil?
               end
               def group_by_column
                 groupable_columns.detect {|c| c.groupable && c.name.to_s == group_by}
               end
               def group_by_statement
                 group_by_column.try(:groupable)
               end
               def project_statement
                 project_clauses = []
                 if project && !project.descendants.active.empty?
                   ids = [project.id]
                   if has_filter?("subproject_id")
                     case operator_for("subproject_id")
                     when '='
                       # include the selected subprojects
                       ids += values_for("subproject_id").each(&:to_i)
                     when '!*'
                       # main project only
                     else
                       # all subprojects
                       ids += project.descendants.collect(&:id)
                     end
                   elsif Setting.display_subprojects_issues?
                     ids += project.descendants.collect(&:id)
                   end
                   project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')
                 elsif project
                   project_clauses << "#{Project.table_name}.id = %d" % project.id
                 end
                 project_clauses.any? ? project_clauses.join(' AND ') : nil
               end
               def statement
                 # filters clauses
                 filters_clauses = []
                 filters.each_key do |field|
                   next if field == "subproject_id"
                   v = values_for(field).clone
                   next unless v and !v.empty?
                   operator = operator_for(field)
                   # "me" value substitution
                   if %w(assigned_to_id author_id user_id watcher_id).include?(field)
                     if v.delete("me")
                       if User.current.logged?
                         v.push(User.current.id.to_s)
                         v += User.current.group_ids.map(&:to_s) if field == 'assigned_to_id'
                       else
                         v.push("0")
                       end
                     end
                   end
                   if field == 'project_id'
                     if v.delete('mine')
                       v += User.current.memberships.map(&:project_id).map(&:to_s)
                     end
                   end
                   if field =~ /cf_(\d+)$/
                     # custom field
                     filters_clauses << sql_for_custom_field(field, operator, v, $1)
                   elsif respond_to?("sql_for_#{field}_field")
                     # specific statement
                     filters_clauses << send("sql_for_#{field}_field", field, operator, v)
                   else
                     # regular field
                     filters_clauses << '(' + sql_for_field(field, operator, v, queried_table_name, field) + ')'
                   end
                 end if filters and valid?
                 if (c = group_by_column) && c.is_a?(QueryCustomFieldColumn)
                   # Excludes results for which the grouped custom field is not visible
                   filters_clauses << c.custom_field.visibility_by_project_condition
                 end
                 filters_clauses << project_statement
                 filters_clauses.reject!(&:blank?)
                 filters_clauses.any? ? filters_clauses.join(' AND ') : nil
               end
               private
               def sql_for_custom_field(field, operator, value, custom_field_id)
                 db_table = CustomValue.table_name
                 db_field = 'value'
                 filter = @available_filters[field]
                 return nil unless filter
                 if filter[:field].format.target_class && filter[:field].format.target_class <= User
                   if value.delete('me')
                     value.push User.current.id.to_s
                   end
                 end
                 not_in = nil
                 if operator == '!'
                   # Makes ! operator work for custom fields with multiple values
                   operator = '='
                   not_in = 'NOT'
                 end
                 customized_key = "id"
                 customized_class = queried_class
                 if field =~ /^(.+)\.cf_/
                   assoc = $1
                   customized_key = "#{assoc}_id"
                   customized_class = queried_class.reflect_on_association(assoc.to_sym).klass.base_class rescue nil
                   raise "Unknown #{queried_class.name} association #{assoc}" unless customized_class
                 end
                 where = sql_for_field(field, operator, value, db_table, db_field, true)
                 if operator =~ /[<>]/
                   where = "(#{where}) AND #{db_table}.#{db_field} <> ''"
                 end
                 "#{queried_table_name}.#{customized_key} #{not_in} IN (" +
                   "SELECT #{customized_class.table_name}.id FROM #{customized_class.table_name}" +
                   " LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='#{customized_class}' AND #{db_table}.customized_id=#{customized_class.table_name}.id AND #{db_table}.custom_field_id=#{custom_field_id}" +
                   " WHERE (#{where}) AND (#{filter[:field].visibility_by_project_condition}))"
               end
               # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+
               def sql_for_field(field, operator, value, db_table, db_field, is_custom_filter=false)
                 sql = ''
                 case operator
                 when "="
                   if value.any?
                     case type_for(field)
                     when :date, :date_past
                       sql = date_clause(db_table, db_field, parse_date(value.first), parse_date(value.first))
                     when :integer
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(CASE #{db_table}.#{db_field} WHEN '' THEN '0' ELSE #{db_table}.#{db_field} END AS decimal(30,3)) = #{value.first.to_i})"
                       else
                         sql = "#{db_table}.#{db_field} = #{value.first.to_i}"
                       end
                     when :float
                       if is_custom_filter
                         sql = "(#{db_table}.#{db_field} <> '' AND CAST(CASE #{db_table}.#{db_field} WHEN '' THEN '0' ELSE #{db_table}.#{db_field} END AS decimal(30,3)) BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5})"
                       else
                         sql = "#{db_table}.#{db_field} BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5}"
                       end
                     else
                       sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{self.class.connection.quote_string(val)}'"}.join(",") + ")"
                     end
                   else
                     # IN an empty set
                     sql = "1=0"
                   end
                 when "!"
                   if value.any?
                     sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{self.class.connection.quote_string(val)}'"}.join(",") + "))"
                   else
                     # NOT IN an empty set
                     sql = "1=1"
                   end
                 when "!*"
                   sql = "#{db_table}.#{db_field} IS NULL"
                   sql << " OR #{db_table}.#{db_field} = ''" if is_custom_filter
                 when "*"
                   sql = "#{db_table}.#{db_field} IS NOT NULL"
                   sql << " AND #{db_table}.#{db_field} <> ''" if is_custom_filter
                 when ">="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, parse_date(value.first), nil)
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(CASE #{db_table}.#{db_field} WHEN '' THEN '0' ELSE #{db_table}.#{db_field} END AS decimal(30,3)) >= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} >= #{value.first.to_f}"
                     end
                   end
                 when "<="
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, nil, parse_date(value.first))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(CASE #{db_table}.#{db_field} WHEN '' THEN '0' ELSE #{db_table}.#{db_field} END AS decimal(30,3)) <= #{value.first.to_f})"
                     else
                       sql = "#{db_table}.#{db_field} <= #{value.first.to_f}"
                     end
                   end
                 when "><"
                   if [:date, :date_past].include?(type_for(field))
                     sql = date_clause(db_table, db_field, parse_date(value[0]), parse_date(value[1]))
                   else
                     if is_custom_filter
                       sql = "(#{db_table}.#{db_field} <> '' AND CAST(CASE #{db_table}.#{db_field} WHEN '' THEN '0' ELSE #{db_table}.#{db_field} END AS decimal(30,3)) BETWEEN #{value[0].to_f} AND #{value[1].to_f})"
                     else
                       sql = "#{db_table}.#{db_field} BETWEEN #{value[0].to_f} AND #{value[1].to_f}"
                     end
                   end
                 when "o"
                   sql = "#{queried_table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{self.class.connection.quoted_false})" if field == "status_id"
                 when "c"
                   sql = "#{queried_table_name}.status_id IN (SELECT id FROM #{IssueStatus.table_name} WHERE is_closed=#{self.class.connection.quoted_true})" if field == "status_id"
                 when "><t-"
                   # between today - n days and today
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, 0)
                 when ">t-"
                   # >= today - n days
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, nil)
                 when "<t-"
                   # <= today - n days
                   sql = relative_date_clause(db_table, db_field, nil, - value.first.to_i)
                 when "t-"
                   # = n days in past
                   sql = relative_date_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
                 when "><t+"
                   # between today and today + n days
                   sql = relative_date_clause(db_table, db_field, 0, value.first.to_i)
                 when ">t+"
                   # >= today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, nil)
                 when "<t+"
                   # <= today + n days
                   sql = relative_date_clause(db_table, db_field, nil, value.first.to_i)
                 when "t+"
                   # = today + n days
                   sql = relative_date_clause(db_table, db_field, value.first.to_i, value.first.to_i)
                 when "t"
                   # = today
                   sql = relative_date_clause(db_table, db_field, 0, 0)
                 when "ld"
                   # = yesterday
                   sql = relative_date_clause(db_table, db_field, -1, -1)
                 when "w"
                   # = this week
                   first_day_of_week = l(:general_first_day_of_week).to_i
                   day_of_week = Date.today.cwday
                   days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
                   sql = relative_date_clause(db_table, db_field, - days_ago, - days_ago + 6)
                 when "lw"
                   # = last week
                   first_day_of_week = l(:general_first_day_of_week).to_i
                   day_of_week = Date.today.cwday
                   days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
                   sql = relative_date_clause(db_table, db_field, - days_ago - 7, - days_ago - 1)
                 when "l2w"
                   # = last 2 weeks
                   first_day_of_week = l(:general_first_day_of_week).to_i
                   day_of_week = Date.today.cwday
                   days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
                   sql = relative_date_clause(db_table, db_field, - days_ago - 14, - days_ago - 1)
                 when "m"
                   # = this month
                   date = Date.today
                   sql = date_clause(db_table, db_field, date.beginning_of_month, date.end_of_month)
                 when "lm"
                   # = last month
                   date = Date.today.prev_month
                   sql = date_clause(db_table, db_field, date.beginning_of_month, date.end_of_month)
                 when "y"
                   # = this year
                   date = Date.today
                   sql = date_clause(db_table, db_field, date.beginning_of_year, date.end_of_year)
                 when "~"
                   sql = "LOWER(#{db_table}.#{db_field}) LIKE '%#{self.class.connection.quote_string(value.first.to_s.downcase)}%'"
                 when "!~"
                   sql = "LOWER(#{db_table}.#{db_field}) NOT LIKE '%#{self.class.connection.quote_string(value.first.to_s.downcase)}%'"
                 else
                   raise "Unknown query operator #{operator}"
                 end
                 return sql
               end
               # Adds a filter for the given custom field
               def add_custom_field_filter(field, assoc=nil)
                 options = field.format.query_filter_options(field, self)
                 if field.format.target_class && field.format.target_class <= User
                   if options[:values].is_a?(Array) && User.current.logged?
                     options[:values].unshift ["<< #{l(:label_me)} >>", "me"]
                   end
                 end
                 filter_id = "cf_#{field.id}"
                 filter_name = field.name
                 if assoc.present?
                   filter_id = "#{assoc}.#{filter_id}"
                   filter_name = l("label_attribute_of_#{assoc}", :name => filter_name)
                 end
                 add_available_filter filter_id, options.merge({
                   :name => filter_name,
                   :field => field
                 })
               end
               # Adds filters for the given custom fields scope
               def add_custom_fields_filters(scope, assoc=nil)
                 scope.visible.where(:is_filter => true).sorted.each do |field|
                   add_custom_field_filter(field, assoc)
                 end
               end
               # Adds filters for the given associations custom fields
               def add_associations_custom_fields_filters(*associations)
                 fields_by_class = CustomField.visible.where(:is_filter => true).group_by(&:class)
                 associations.each do |assoc|
                   association_klass = queried_class.reflect_on_association(assoc).klass
                   fields_by_class.each do |field_class, fields|
                     if field_class.customized_class <= association_klass
                       fields.sort.each do |field|
                         add_custom_field_filter(field, assoc)
                       end
                     end
                   end
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_clause(table, field, from, to)
                 s = []
                 if from
                   if from.is_a?(Date)
                     from = Time.local(from.year, from.month, from.day).yesterday.end_of_day
                   else
                     from = from - 1 # second
                   end
                   if self.class.default_timezone == :utc
                     from = from.utc
                   end
                   s << ("#{table}.#{field} > '%s'" % [self.class.connection.quoted_date(from)])
                 end
                 if to
                   if to.is_a?(Date)
                     to = Time.local(to.year, to.month, to.day).end_of_day
                   end
                   if self.class.default_timezone == :utc
                     to = to.utc
                   end
                   s << ("#{table}.#{field} <= '%s'" % [self.class.connection.quoted_date(to)])
                 end
                 s.join(' AND ')
               end
               # Returns a SQL clause for a date or datetime field using relative dates.
               def relative_date_clause(table, field, days_from, days_to)
                 date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))
               end
               # Returns a Date or Time from the given filter value
               def parse_date(arg)
                 if arg.to_s =~ /\A\d{4}-\d{2}-\d{2}T/
                   Time.parse(arg) rescue nil
                 else
                   Date.parse(arg) rescue nil
                 end
               end
               # Additional joins required for the given sort options
               def joins_for_order_statement(order_options)
                 joins = []
                 if order_options
                   if order_options.include?('authors')
                     joins << "LEFT OUTER JOIN #{User.table_name} authors ON authors.id = #{queried_table_name}.author_id"
                   end
                   order_options.scan(/cf_\d+/).uniq.each do |name|
                     column = available_columns.detect {|c| c.name.to_s == name}
                     join = column && column.custom_field.join_for_order_statement
                     if join
                       joins << join
                     end
                   end
                 end
                 joins.any? ? joins.join(' ') : nil
               end
             end

             # 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 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
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('due_date', 'w', [''])
                 find_issues_with_query(query)
               end
               def test_operator_this_week_on_datetime
                 query = IssueQuery.new(:project => Project.find(1), :name => '_')
                 query.add_filter('created_on', 'w', [''])
                 find_issues_with_query(query)
               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_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
               context "#statement" do
                 context "with 'member_of_group' filter" do
                   setup do
                     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
                   end
                   should "search assigned to for users in the group" do
                     @query = IssueQuery.new(:name => '_')
                     @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
                   should "search not assigned to any group member (none)" do
                     @query = IssueQuery.new(:name => '_')
                     @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
                   should "search assigned to any group member (all)" do
                     @query = IssueQuery.new(:name => '_')
                     @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
                   should "return an empty set with = empty group" do
                     @empty_group = Group.generate!
                     @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '=', [@empty_group.id.to_s])
                     assert_equal [], find_issues_with_query(@query)
                   end
                   should "return issues with ! empty group" do
                     @empty_group = Group.generate!
                     @query = IssueQuery.new(:name => '_')
                     @query.add_filter('member_of_group', '!', [@empty_group.id.to_s])
                     assert_find_issues_with_query_is_successful @query
                   end
                 end
                 context "with 'assigned_to_role' filter" do
                   setup do
                     @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)
                   end
                   should "search assigned to for users with the Role" do
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                     assert_query_result [@issue1, @issue3], @query
                   end
                   should "search assigned to for users with the Role on the issue project" do
                     other_project = Project.generate!
                     User.add_to_project(@developer, other_project, @manager_role)
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@manager_role.id.to_s])
                     assert_query_result [@issue1, @issue3], @query
                   end
                   should "return an empty set with empty role" do
                     @empty_role = Role.generate!
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '=', [@empty_role.id.to_s])
                     assert_query_result [], @query
                   end
                   should "search assigned to for users without the Role" do
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!', [@manager_role.id.to_s])
                     assert_query_result [@issue2, @issue4, @issue5], @query
                   end
                   should "search assigned to for users not assigned to any Role (none)" do
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!*', [''])
                     assert_query_result [@issue4, @issue5], @query
                   end
                   should "search assigned to for users assigned to any Role (all)" do
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '*', [''])
                     assert_query_result [@issue1, @issue2, @issue3], @query
                   end
                   should "return issues with ! empty role" do
                     @empty_role = Role.generate!
                     @query = IssueQuery.new(:name => '_', :project => @project)
                     @query.add_filter('assigned_to_role', '!', [@empty_role.id.to_s])
                     assert_query_result [@issue1, @issue2, @issue3, @issue4, @issue5], @query
                   end
                 end
               end
+              def test_query_column_should_accept_a_symbol_as_caption
+                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