jro_apps/redmine Commit - r10437:8487a3e0e63f

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 IssueTest < ActiveSupport::TestCase

20

class IssueTest < ActiveSupport::TestCase

21

fixtures :projects, :users, :members, :member_roles, :roles,

21

fixtures :projects, :users, :members, :member_roles, :roles,

22

:groups_users,

22

:groups_users,

23

:trackers, :projects_trackers,

23

:trackers, :projects_trackers,

24

:enabled_modules,

24

:enabled_modules,

25

:versions,

25

:versions,

26

:issue_statuses, :issue_categories, :issue_relations, :workflows,

26

:issue_statuses, :issue_categories, :issue_relations, :workflows,

27

:enumerations,

27

:enumerations,

28

:issues, :journals, :journal_details,

28

:issues, :journals, :journal_details,

29

:custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,

29

:custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,

30

:time_entries

30

:time_entries

31

32

include Redmine::I18n

32

include Redmine::I18n

33

34

def teardown

34

def teardown

35

User.current = nil

35

User.current = nil

36

end

36

end

37

38

def test_create

38

def test_create

39

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,

39

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,

40

:status_id => 1, :priority => IssuePriority.all.first,

40

:status_id => 1, :priority => IssuePriority.all.first,

41

:subject => 'test_create',

41

:subject => 'test_create',

42

:description => 'IssueTest#test_create', :estimated_hours => '1:30')

42

:description => 'IssueTest#test_create', :estimated_hours => '1:30')

43

assert issue.save

43

assert issue.save

44

issue.reload

44

issue.reload

45

assert_equal 1.5, issue.estimated_hours

45

assert_equal 1.5, issue.estimated_hours

46

end

46

end

47

48

def test_create_minimal

48

def test_create_minimal

49

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,

49

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,

50

:status_id => 1, :priority => IssuePriority.all.first,

50

:status_id => 1, :priority => IssuePriority.all.first,

51

:subject => 'test_create')

51

:subject => 'test_create')

52

assert issue.save

52

assert issue.save

53

assert issue.description.nil?

53

assert issue.description.nil?

54

assert_nil issue.estimated_hours

54

assert_nil issue.estimated_hours

55

end

55

end

56

57

def test_create_with_required_custom_field

57

def test_create_with_required_custom_field

58

set_language_if_valid 'en'

58

set_language_if_valid 'en'

59

field = IssueCustomField.find_by_name('Database')

59

field = IssueCustomField.find_by_name('Database')

60

field.update_attribute(:is_required, true)

60

field.update_attribute(:is_required, true)

61

62

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

62

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

63

:status_id => 1, :subject => 'test_create',

63

:status_id => 1, :subject => 'test_create',

64

:description => 'IssueTest#test_create_with_required_custom_field')

64

:description => 'IssueTest#test_create_with_required_custom_field')

65

assert issue.available_custom_fields.include?(field)

65

assert issue.available_custom_fields.include?(field)

66

# No value for the custom field

66

# No value for the custom field

67

assert !issue.save

67

assert !issue.save

68

assert_equal ["Database can't be blank"], issue.errors.full_messages

68

assert_equal ["Database can't be blank"], issue.errors.full_messages

69

# Blank value

69

# Blank value

70

issue.custom_field_values = { field.id => '' }

70

issue.custom_field_values = { field.id => '' }

71

assert !issue.save

71

assert !issue.save

72

assert_equal ["Database can't be blank"], issue.errors.full_messages

72

assert_equal ["Database can't be blank"], issue.errors.full_messages

73

# Invalid value

73

# Invalid value

74

issue.custom_field_values = { field.id => 'SQLServer' }

74

issue.custom_field_values = { field.id => 'SQLServer' }

75

assert !issue.save

75

assert !issue.save

76

assert_equal ["Database is not included in the list"], issue.errors.full_messages

76

assert_equal ["Database is not included in the list"], issue.errors.full_messages

77

# Valid value

77

# Valid value

78

issue.custom_field_values = { field.id => 'PostgreSQL' }

78

issue.custom_field_values = { field.id => 'PostgreSQL' }

79

assert issue.save

79

assert issue.save

80

issue.reload

80

issue.reload

81

assert_equal 'PostgreSQL', issue.custom_value_for(field).value

81

assert_equal 'PostgreSQL', issue.custom_value_for(field).value

82

end

82

end

83

84

def test_create_with_group_assignment

84

def test_create_with_group_assignment

85

with_settings :issue_group_assignment => '1' do

85

with_settings :issue_group_assignment => '1' do

86

assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,

86

assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,

87

:subject => 'Group assignment',

87

:subject => 'Group assignment',

88

:assigned_to_id => 11).save

88

:assigned_to_id => 11).save

89

issue = Issue.first(:order => 'id DESC')

89

issue = Issue.first(:order => 'id DESC')

90

assert_kind_of Group, issue.assigned_to

90

assert_kind_of Group, issue.assigned_to

91

assert_equal Group.find(11), issue.assigned_to

91

assert_equal Group.find(11), issue.assigned_to

92

end

92

end

93

end

93

end

94

95

def test_create_with_parent_issue_id

95

def test_create_with_parent_issue_id

96

issue = Issue.new(:project_id => 1, :tracker_id => 1,

96

issue = Issue.new(:project_id => 1, :tracker_id => 1,

97

:author_id => 1, :subject => 'Group assignment',

97

:author_id => 1, :subject => 'Group assignment',

98

:parent_issue_id => 1)

98

:parent_issue_id => 1)

99

assert_save issue

99

assert_save issue

100

assert_equal 1, issue.parent_issue_id

100

assert_equal 1, issue.parent_issue_id

101

assert_equal Issue.find(1), issue.parent

101

assert_equal Issue.find(1), issue.parent

102

end

102

end

103

104

def test_create_with_sharp_parent_issue_id

104

def test_create_with_sharp_parent_issue_id

105

issue = Issue.new(:project_id => 1, :tracker_id => 1,

105

issue = Issue.new(:project_id => 1, :tracker_id => 1,

106

:author_id => 1, :subject => 'Group assignment',

106

:author_id => 1, :subject => 'Group assignment',

107

:parent_issue_id => "#1")

107

:parent_issue_id => "#1")

108

assert_save issue

108

assert_save issue

109

assert_equal 1, issue.parent_issue_id

109

assert_equal 1, issue.parent_issue_id

110

assert_equal Issue.find(1), issue.parent

110

assert_equal Issue.find(1), issue.parent

111

end

111

end

112

113

def test_create_with_invalid_parent_issue_id

113

def test_create_with_invalid_parent_issue_id

114

set_language_if_valid 'en'

114

set_language_if_valid 'en'

115

issue = Issue.new(:project_id => 1, :tracker_id => 1,

115

issue = Issue.new(:project_id => 1, :tracker_id => 1,

116

:author_id => 1, :subject => 'Group assignment',

116

:author_id => 1, :subject => 'Group assignment',

117

:parent_issue_id => '01ABC')

117

:parent_issue_id => '01ABC')

118

assert !issue.save

118

assert !issue.save

119

assert_equal '01ABC', issue.parent_issue_id

119

assert_equal '01ABC', issue.parent_issue_id

120

assert_include 'Parent task is invalid', issue.errors.full_messages

120

assert_include 'Parent task is invalid', issue.errors.full_messages

121

end

121

end

122

123

def test_create_with_invalid_sharp_parent_issue_id

123

def test_create_with_invalid_sharp_parent_issue_id

124

set_language_if_valid 'en'

124

set_language_if_valid 'en'

125

issue = Issue.new(:project_id => 1, :tracker_id => 1,

125

issue = Issue.new(:project_id => 1, :tracker_id => 1,

126

:author_id => 1, :subject => 'Group assignment',

126

:author_id => 1, :subject => 'Group assignment',

127

:parent_issue_id => '#01ABC')

127

:parent_issue_id => '#01ABC')

128

assert !issue.save

128

assert !issue.save

129

assert_equal '#01ABC', issue.parent_issue_id

129

assert_equal '#01ABC', issue.parent_issue_id

130

assert_include 'Parent task is invalid', issue.errors.full_messages

130

assert_include 'Parent task is invalid', issue.errors.full_messages

131

end

131

end

132

133

def assert_visibility_match(user, issues)

133

def assert_visibility_match(user, issues)

134

assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort

134

assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort

135

end

135

end

136

137

def test_visible_scope_for_anonymous

137

def test_visible_scope_for_anonymous

138

# Anonymous user should see issues of public projects only

138

# Anonymous user should see issues of public projects only

139

issues = Issue.visible(User.anonymous).all

139

issues = Issue.visible(User.anonymous).all

140

assert issues.any?

140

assert issues.any?

141

assert_nil issues.detect {|issue| !issue.project.is_public?}

141

assert_nil issues.detect {|issue| !issue.project.is_public?}

142

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

142

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

143

assert_visibility_match User.anonymous, issues

143

assert_visibility_match User.anonymous, issues

144

end

144

end

145

146

def test_visible_scope_for_anonymous_without_view_issues_permissions

146

def test_visible_scope_for_anonymous_without_view_issues_permissions

147

# Anonymous user should not see issues without permission

147

# Anonymous user should not see issues without permission

148

Role.anonymous.remove_permission!(:view_issues)

148

Role.anonymous.remove_permission!(:view_issues)

149

issues = Issue.visible(User.anonymous).all

149

issues = Issue.visible(User.anonymous).all

150

assert issues.empty?

150

assert issues.empty?

151

assert_visibility_match User.anonymous, issues

151

assert_visibility_match User.anonymous, issues

152

end

152

end

153

154

def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default

154

def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default

155

assert Role.anonymous.update_attribute(:issues_visibility, 'default')

155

assert Role.anonymous.update_attribute(:issues_visibility, 'default')

156

issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)

156

issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)

157

assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first

157

assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first

158

assert !issue.visible?(User.anonymous)

158

assert !issue.visible?(User.anonymous)

159

end

159

end

160

161

def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own

161

def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own

162

assert Role.anonymous.update_attribute(:issues_visibility, 'own')

162

assert Role.anonymous.update_attribute(:issues_visibility, 'own')

163

issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)

163

issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)

164

assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first

164

assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first

165

assert !issue.visible?(User.anonymous)

165

assert !issue.visible?(User.anonymous)

166

end

166

end

167

168

def test_visible_scope_for_non_member

168

def test_visible_scope_for_non_member

169

user = User.find(9)

169

user = User.find(9)

170

assert user.projects.empty?

170

assert user.projects.empty?

171

# Non member user should see issues of public projects only

171

# Non member user should see issues of public projects only

172

issues = Issue.visible(user).all

172

issues = Issue.visible(user).all

173

assert issues.any?

173

assert issues.any?

174

assert_nil issues.detect {|issue| !issue.project.is_public?}

174

assert_nil issues.detect {|issue| !issue.project.is_public?}

175

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

175

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

176

assert_visibility_match user, issues

176

assert_visibility_match user, issues

177

end

177

end

178

179

def test_visible_scope_for_non_member_with_own_issues_visibility

179

def test_visible_scope_for_non_member_with_own_issues_visibility

180

Role.non_member.update_attribute :issues_visibility, 'own'

180

Role.non_member.update_attribute :issues_visibility, 'own'

181

Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')

181

Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')

182

user = User.find(9)

182

user = User.find(9)

183

184

issues = Issue.visible(user).all

184

issues = Issue.visible(user).all

185

assert issues.any?

185

assert issues.any?

186

assert_nil issues.detect {|issue| issue.author != user}

186

assert_nil issues.detect {|issue| issue.author != user}

187

assert_visibility_match user, issues

187

assert_visibility_match user, issues

188

end

188

end

189

190

def test_visible_scope_for_non_member_without_view_issues_permissions

190

def test_visible_scope_for_non_member_without_view_issues_permissions

191

# Non member user should not see issues without permission

191

# Non member user should not see issues without permission

192

Role.non_member.remove_permission!(:view_issues)

192

Role.non_member.remove_permission!(:view_issues)

193

user = User.find(9)

193

user = User.find(9)

194

assert user.projects.empty?

194

assert user.projects.empty?

195

issues = Issue.visible(user).all

195

issues = Issue.visible(user).all

196

assert issues.empty?

196

assert issues.empty?

197

assert_visibility_match user, issues

197

assert_visibility_match user, issues

198

end

198

end

199

200

def test_visible_scope_for_member

200

def test_visible_scope_for_member

201

user = User.find(9)

201

user = User.find(9)

202

# User should see issues of projects for which he has view_issues permissions only

202

# User should see issues of projects for which he has view_issues permissions only

203

Role.non_member.remove_permission!(:view_issues)

203

Role.non_member.remove_permission!(:view_issues)

204

Member.create!(:principal => user, :project_id => 3, :role_ids => [2])

204

Member.create!(:principal => user, :project_id => 3, :role_ids => [2])

205

issues = Issue.visible(user).all

205

issues = Issue.visible(user).all

206

assert issues.any?

206

assert issues.any?

207

assert_nil issues.detect {|issue| issue.project_id != 3}

207

assert_nil issues.detect {|issue| issue.project_id != 3}

208

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

208

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

209

assert_visibility_match user, issues

209

assert_visibility_match user, issues

210

end

210

end

211

212

def test_visible_scope_for_member_with_groups_should_return_assigned_issues

212

def test_visible_scope_for_member_with_groups_should_return_assigned_issues

213

user = User.find(8)

213

user = User.find(8)

214

assert user.groups.any?

214

assert user.groups.any?

215

Member.create!(:principal => user.groups.first, :project_id => 1, :role_ids => [2])

215

Member.create!(:principal => user.groups.first, :project_id => 1, :role_ids => [2])

216

Role.non_member.remove_permission!(:view_issues)

216

Role.non_member.remove_permission!(:view_issues)

217

218

issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,

218

issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,

219

:status_id => 1, :priority => IssuePriority.all.first,

219

:status_id => 1, :priority => IssuePriority.all.first,

220

:subject => 'Assignment test',

220

:subject => 'Assignment test',

221

:assigned_to => user.groups.first,

221

:assigned_to => user.groups.first,

222

:is_private => true)

222

:is_private => true)

223

224

Role.find(2).update_attribute :issues_visibility, 'default'

224

Role.find(2).update_attribute :issues_visibility, 'default'

225

issues = Issue.visible(User.find(8)).all

225

issues = Issue.visible(User.find(8)).all

226

assert issues.any?

226

assert issues.any?

227

assert issues.include?(issue)

227

assert issues.include?(issue)

228

229

Role.find(2).update_attribute :issues_visibility, 'own'

229

Role.find(2).update_attribute :issues_visibility, 'own'

230

issues = Issue.visible(User.find(8)).all

230

issues = Issue.visible(User.find(8)).all

231

assert issues.any?

231

assert issues.any?

232

assert issues.include?(issue)

232

assert issues.include?(issue)

233

end

233

end

234

235

def test_visible_scope_for_admin

235

def test_visible_scope_for_admin

236

user = User.find(1)

236

user = User.find(1)

237

user.members.each(&:destroy)

237

user.members.each(&:destroy)

238

assert user.projects.empty?

238

assert user.projects.empty?

239

issues = Issue.visible(user).all

239

issues = Issue.visible(user).all

240

assert issues.any?

240

assert issues.any?

241

# Admin should see issues on private projects that he does not belong to

241

# Admin should see issues on private projects that he does not belong to

242

assert issues.detect {|issue| !issue.project.is_public?}

242

assert issues.detect {|issue| !issue.project.is_public?}

243

# Admin should see private issues of other users

243

# Admin should see private issues of other users

244

assert issues.detect {|issue| issue.is_private? && issue.author != user}

244

assert issues.detect {|issue| issue.is_private? && issue.author != user}

245

assert_visibility_match user, issues

245

assert_visibility_match user, issues

246

end

246

end

247

248

def test_visible_scope_with_project

248

def test_visible_scope_with_project

249

project = Project.find(1)

249

project = Project.find(1)

250

issues = Issue.visible(User.find(2), :project => project).all

250

issues = Issue.visible(User.find(2), :project => project).all

251

projects = issues.collect(&:project).uniq

251

projects = issues.collect(&:project).uniq

252

assert_equal 1, projects.size

252

assert_equal 1, projects.size

253

assert_equal project, projects.first

253

assert_equal project, projects.first

254

end

254

end

255

256

def test_visible_scope_with_project_and_subprojects

256

def test_visible_scope_with_project_and_subprojects

257

project = Project.find(1)

257

project = Project.find(1)

258

issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all

258

issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all

259

projects = issues.collect(&:project).uniq

259

projects = issues.collect(&:project).uniq

260

assert projects.size > 1

260

assert projects.size > 1

261

assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}

261

assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}

262

end

262

end

263

264

def test_visible_and_nested_set_scopes

264

def test_visible_and_nested_set_scopes

265

assert_equal 0, Issue.find(1).descendants.visible.all.size

265

assert_equal 0, Issue.find(1).descendants.visible.all.size

266

end

266

end

267

268

def test_open_scope

268

def test_open_scope

269

issues = Issue.open.all

269

issues = Issue.open.all

270

assert_nil issues.detect(&:closed?)

270

assert_nil issues.detect(&:closed?)

271

end

271

end

272

273

def test_open_scope_with_arg

273

def test_open_scope_with_arg

274

issues = Issue.open(false).all

274

issues = Issue.open(false).all

275

assert_equal issues, issues.select(&:closed?)

275

assert_equal issues, issues.select(&:closed?)

276

end

276

end

277

278

def test_errors_full_messages_should_include_custom_fields_errors

278

def test_errors_full_messages_should_include_custom_fields_errors

279

field = IssueCustomField.find_by_name('Database')

279

field = IssueCustomField.find_by_name('Database')

280

281

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

281

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

282

:status_id => 1, :subject => 'test_create',

282

:status_id => 1, :subject => 'test_create',

283

:description => 'IssueTest#test_create_with_required_custom_field')

283

:description => 'IssueTest#test_create_with_required_custom_field')

284

assert issue.available_custom_fields.include?(field)

284

assert issue.available_custom_fields.include?(field)

285

# Invalid value

285

# Invalid value

286

issue.custom_field_values = { field.id => 'SQLServer' }

286

issue.custom_field_values = { field.id => 'SQLServer' }

287

288

assert !issue.valid?

288

assert !issue.valid?

289

assert_equal 1, issue.errors.full_messages.size

289

assert_equal 1, issue.errors.full_messages.size

290

assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",

290

assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",

291

issue.errors.full_messages.first

291

issue.errors.full_messages.first

292

end

292

end

293

294

def test_update_issue_with_required_custom_field

294

def test_update_issue_with_required_custom_field

295

field = IssueCustomField.find_by_name('Database')

295

field = IssueCustomField.find_by_name('Database')

296

field.update_attribute(:is_required, true)

296

field.update_attribute(:is_required, true)

297

298

issue = Issue.find(1)

298

issue = Issue.find(1)

299

assert_nil issue.custom_value_for(field)

299

assert_nil issue.custom_value_for(field)

300

assert issue.available_custom_fields.include?(field)

300

assert issue.available_custom_fields.include?(field)

301

# No change to custom values, issue can be saved

301

# No change to custom values, issue can be saved

302

assert issue.save

302

assert issue.save

303

# Blank value

303

# Blank value

304

issue.custom_field_values = { field.id => '' }

304

issue.custom_field_values = { field.id => '' }

305

assert !issue.save

305

assert !issue.save

306

# Valid value

306

# Valid value

307

issue.custom_field_values = { field.id => 'PostgreSQL' }

307

issue.custom_field_values = { field.id => 'PostgreSQL' }

308

assert issue.save

308

assert issue.save

309

issue.reload

309

issue.reload

310

assert_equal 'PostgreSQL', issue.custom_value_for(field).value

310

assert_equal 'PostgreSQL', issue.custom_value_for(field).value

311

end

311

end

312

313

def test_should_not_update_attributes_if_custom_fields_validation_fails

313

def test_should_not_update_attributes_if_custom_fields_validation_fails

314

issue = Issue.find(1)

314

issue = Issue.find(1)

315

field = IssueCustomField.find_by_name('Database')

315

field = IssueCustomField.find_by_name('Database')

316

assert issue.available_custom_fields.include?(field)

316

assert issue.available_custom_fields.include?(field)

317

318

issue.custom_field_values = { field.id => 'Invalid' }

318

issue.custom_field_values = { field.id => 'Invalid' }

319

issue.subject = 'Should be not be saved'

319

issue.subject = 'Should be not be saved'

320

assert !issue.save

320

assert !issue.save

321

322

issue.reload

322

issue.reload

323

assert_equal "Can't print recipes", issue.subject

323

assert_equal "Can't print recipes", issue.subject

324

end

324

end

325

326

def test_should_not_recreate_custom_values_objects_on_update

326

def test_should_not_recreate_custom_values_objects_on_update

327

field = IssueCustomField.find_by_name('Database')

327

field = IssueCustomField.find_by_name('Database')

328

329

issue = Issue.find(1)

329

issue = Issue.find(1)

330

issue.custom_field_values = { field.id => 'PostgreSQL' }

330

issue.custom_field_values = { field.id => 'PostgreSQL' }

331

assert issue.save

331

assert issue.save

332

custom_value = issue.custom_value_for(field)

332

custom_value = issue.custom_value_for(field)

333

issue.reload

333

issue.reload

334

issue.custom_field_values = { field.id => 'MySQL' }

334

issue.custom_field_values = { field.id => 'MySQL' }

335

assert issue.save

335

assert issue.save

336

issue.reload

336

issue.reload

337

assert_equal custom_value.id, issue.custom_value_for(field).id

337

assert_equal custom_value.id, issue.custom_value_for(field).id

338

end

338

end

339

340

def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields

340

def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields

341

issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,

341

issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,

342

:status_id => 1, :subject => 'Test',

342

:status_id => 1, :subject => 'Test',

343

:custom_field_values => {'2' => 'Test'})

343

:custom_field_values => {'2' => 'Test'})

344

assert !Tracker.find(2).custom_field_ids.include?(2)

344

assert !Tracker.find(2).custom_field_ids.include?(2)

345

346

issue = Issue.find(issue.id)

346

issue = Issue.find(issue.id)

347

issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}

347

issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}

348

349

issue = Issue.find(issue.id)

349

issue = Issue.find(issue.id)

350

custom_value = issue.custom_value_for(2)

350

custom_value = issue.custom_value_for(2)

351

assert_not_nil custom_value

351

assert_not_nil custom_value

352

assert_equal 'Test', custom_value.value

352

assert_equal 'Test', custom_value.value

353

end

353

end

354

355

def test_assigning_tracker_id_should_reload_custom_fields_values

355

def test_assigning_tracker_id_should_reload_custom_fields_values

356

issue = Issue.new(:project => Project.find(1))

356

issue = Issue.new(:project => Project.find(1))

357

assert issue.custom_field_values.empty?

357

assert issue.custom_field_values.empty?

358

issue.tracker_id = 1

358

issue.tracker_id = 1

359

assert issue.custom_field_values.any?

359

assert issue.custom_field_values.any?

360

end

360

end

361

362

def test_assigning_attributes_should_assign_project_and_tracker_first

362

def test_assigning_attributes_should_assign_project_and_tracker_first

363

seq = sequence('seq')

363

seq = sequence('seq')

364

issue = Issue.new

364

issue = Issue.new

365

issue.expects(:project_id=).in_sequence(seq)

365

issue.expects(:project_id=).in_sequence(seq)

366

issue.expects(:tracker_id=).in_sequence(seq)

366

issue.expects(:tracker_id=).in_sequence(seq)

367

issue.expects(:subject=).in_sequence(seq)

367

issue.expects(:subject=).in_sequence(seq)

368

issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}

368

issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}

369

end

369

end

370

371

def test_assigning_tracker_and_custom_fields_should_assign_custom_fields

371

def test_assigning_tracker_and_custom_fields_should_assign_custom_fields

372

attributes = ActiveSupport::OrderedHash.new

372

attributes = ActiveSupport::OrderedHash.new

373

attributes['custom_field_values'] = { '1' => 'MySQL' }

373

attributes['custom_field_values'] = { '1' => 'MySQL' }

374

attributes['tracker_id'] = '1'

374

attributes['tracker_id'] = '1'

375

issue = Issue.new(:project => Project.find(1))

375

issue = Issue.new(:project => Project.find(1))

376

issue.attributes = attributes

376

issue.attributes = attributes

377

assert_equal 'MySQL', issue.custom_field_value(1)

377

assert_equal 'MySQL', issue.custom_field_value(1)

378

end

378

end

379

380

def test_should_update_issue_with_disabled_tracker

380

def test_should_update_issue_with_disabled_tracker

381

p = Project.find(1)

381

p = Project.find(1)

382

issue = Issue.find(1)

382

issue = Issue.find(1)

383

384

p.trackers.delete(issue.tracker)

384

p.trackers.delete(issue.tracker)

385

assert !p.trackers.include?(issue.tracker)

385

assert !p.trackers.include?(issue.tracker)

386

387

issue.reload

387

issue.reload

388

issue.subject = 'New subject'

388

issue.subject = 'New subject'

389

assert issue.save

389

assert issue.save

390

end

390

end

391

392

def test_should_not_set_a_disabled_tracker

392

def test_should_not_set_a_disabled_tracker

393

p = Project.find(1)

393

p = Project.find(1)

394

p.trackers.delete(Tracker.find(2))

394

p.trackers.delete(Tracker.find(2))

395

396

issue = Issue.find(1)

396

issue = Issue.find(1)

397

issue.tracker_id = 2

397

issue.tracker_id = 2

398

issue.subject = 'New subject'

398

issue.subject = 'New subject'

399

assert !issue.save

399

assert !issue.save

400

assert_not_nil issue.errors[:tracker_id]

400

assert_not_nil issue.errors[:tracker_id]

401

end

401

end

402

403

def test_category_based_assignment

403

def test_category_based_assignment

404

issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,

404

issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,

405

:status_id => 1, :priority => IssuePriority.all.first,

405

:status_id => 1, :priority => IssuePriority.all.first,

406

:subject => 'Assignment test',

406

:subject => 'Assignment test',

407

:description => 'Assignment test', :category_id => 1)

407

:description => 'Assignment test', :category_id => 1)

408

assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to

408

assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to

409

end

409

end

410

411

def test_new_statuses_allowed_to

411

def test_new_statuses_allowed_to

412

WorkflowTransition.delete_all

412

WorkflowTransition.delete_all

413

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

413

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

414

:old_status_id => 1, :new_status_id => 2,

414

:old_status_id => 1, :new_status_id => 2,

415

:author => false, :assignee => false)

415

:author => false, :assignee => false)

416

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

416

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

417

:old_status_id => 1, :new_status_id => 3,

417

:old_status_id => 1, :new_status_id => 3,

418

:author => true, :assignee => false)

418

:author => true, :assignee => false)

419

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1,

419

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1,

420

:new_status_id => 4, :author => false,

420

:new_status_id => 4, :author => false,

421

:assignee => true)

421

:assignee => true)

422

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

422

WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,

423

:old_status_id => 1, :new_status_id => 5,

423

:old_status_id => 1, :new_status_id => 5,

424

:author => true, :assignee => true)

424

:author => true, :assignee => true)

425

status = IssueStatus.find(1)

425

status = IssueStatus.find(1)

426

role = Role.find(1)

426

role = Role.find(1)

427

tracker = Tracker.find(1)

427

tracker = Tracker.find(1)

428

user = User.find(2)

428

user = User.find(2)

429

430

issue = Issue.generate!(:tracker => tracker, :status => status,

430

issue = Issue.generate!(:tracker => tracker, :status => status,

431

:project_id => 1, :author_id => 1)

431

:project_id => 1, :author_id => 1)

432

assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)

432

assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)

433

434

issue = Issue.generate!(:tracker => tracker, :status => status,

434

issue = Issue.generate!(:tracker => tracker, :status => status,

435

:project_id => 1, :author => user)

435

:project_id => 1, :author => user)

436

assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)

436

assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)

437

438

issue = Issue.generate!(:tracker => tracker, :status => status,

438

issue = Issue.generate!(:tracker => tracker, :status => status,

439

:project_id => 1, :author_id => 1,

439

:project_id => 1, :author_id => 1,

440

:assigned_to => user)

440

:assigned_to => user)

441

assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)

441

assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)

442

443

issue = Issue.generate!(:tracker => tracker, :status => status,

443

issue = Issue.generate!(:tracker => tracker, :status => status,

444

:project_id => 1, :author => user,

444

:project_id => 1, :author => user,

445

:assigned_to => user)

445

:assigned_to => user)

446

assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)

446

assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)

447

end

447

end

448

449

def test_new_statuses_allowed_to_should_return_all_transitions_for_admin

449

def test_new_statuses_allowed_to_should_return_all_transitions_for_admin

450

admin = User.find(1)

450

admin = User.find(1)

451

issue = Issue.find(1)

451

issue = Issue.find(1)

452

assert !admin.member_of?(issue.project)

452

assert !admin.member_of?(issue.project)

453

expected_statuses = [issue.status] +

453

expected_statuses = [issue.status] +

454

WorkflowTransition.find_all_by_old_status_id(

454

WorkflowTransition.find_all_by_old_status_id(

455

issue.status_id).map(&:new_status).uniq.sort

455

issue.status_id).map(&:new_status).uniq.sort

456

assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)

456

assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)

457

end

457

end

458

459

def test_new_statuses_allowed_to_should_return_default_and_current_status_when_copying

459

def test_new_statuses_allowed_to_should_return_default_and_current_status_when_copying

460

issue = Issue.find(1).copy

460

issue = Issue.find(1).copy

461

assert_equal [1], issue.new_statuses_allowed_to(User.find(2)).map(&:id)

461

assert_equal [1], issue.new_statuses_allowed_to(User.find(2)).map(&:id)

462

463

issue = Issue.find(2).copy

463

issue = Issue.find(2).copy

464

assert_equal [1, 2], issue.new_statuses_allowed_to(User.find(2)).map(&:id)

464

assert_equal [1, 2], issue.new_statuses_allowed_to(User.find(2)).map(&:id)

465

end

465

end

466

467

def test_safe_attributes_names_should_not_include_disabled_field

467

def test_safe_attributes_names_should_not_include_disabled_field

468

tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))

468

tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))

469

470

issue = Issue.new(:tracker => tracker)

470

issue = Issue.new(:tracker => tracker)

471

assert_include 'tracker_id', issue.safe_attribute_names

471

assert_include 'tracker_id', issue.safe_attribute_names

472

assert_include 'status_id', issue.safe_attribute_names

472

assert_include 'status_id', issue.safe_attribute_names

473

assert_include 'subject', issue.safe_attribute_names

473

assert_include 'subject', issue.safe_attribute_names

474

assert_include 'description', issue.safe_attribute_names

474

assert_include 'description', issue.safe_attribute_names

475

assert_include 'custom_field_values', issue.safe_attribute_names

475

assert_include 'custom_field_values', issue.safe_attribute_names

476

assert_include 'custom_fields', issue.safe_attribute_names

476

assert_include 'custom_fields', issue.safe_attribute_names

477

assert_include 'lock_version', issue.safe_attribute_names

477

assert_include 'lock_version', issue.safe_attribute_names

478

479

tracker.core_fields.each do |field|

479

tracker.core_fields.each do |field|

480

assert_include field, issue.safe_attribute_names

480

assert_include field, issue.safe_attribute_names

481

end

481

end

482

483

tracker.disabled_core_fields.each do |field|

483

tracker.disabled_core_fields.each do |field|

484

assert_not_include field, issue.safe_attribute_names

484

assert_not_include field, issue.safe_attribute_names

485

end

485

end

486

end

486

end

487

488

def test_safe_attributes_should_ignore_disabled_fields

488

def test_safe_attributes_should_ignore_disabled_fields

489

tracker = Tracker.find(1)

489

tracker = Tracker.find(1)

490

tracker.core_fields = %w(assigned_to_id due_date)

490

tracker.core_fields = %w(assigned_to_id due_date)

491

tracker.save!

491

tracker.save!

492

493

issue = Issue.new(:tracker => tracker)

493

issue = Issue.new(:tracker => tracker)

494

issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}

494

issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}

495

assert_nil issue.start_date

495

assert_nil issue.start_date

496

assert_equal Date.parse('2012-07-14'), issue.due_date

496

assert_equal Date.parse('2012-07-14'), issue.due_date

497

end

497

end

498

499

def test_safe_attributes_should_accept_target_tracker_enabled_fields

499

def test_safe_attributes_should_accept_target_tracker_enabled_fields

500

source = Tracker.find(1)

500

source = Tracker.find(1)

501

source.core_fields = []

501

source.core_fields = []

502

source.save!

502

source.save!

503

target = Tracker.find(2)

503

target = Tracker.find(2)

504

target.core_fields = %w(assigned_to_id due_date)

504

target.core_fields = %w(assigned_to_id due_date)

505

target.save!

505

target.save!

506

507

issue = Issue.new(:tracker => source)

507

issue = Issue.new(:tracker => source)

508

issue.safe_attributes = {'tracker_id' => 2, 'due_date' => '2012-07-14'}

508

issue.safe_attributes = {'tracker_id' => 2, 'due_date' => '2012-07-14'}

509

assert_equal target, issue.tracker

509

assert_equal target, issue.tracker

510

assert_equal Date.parse('2012-07-14'), issue.due_date

510

assert_equal Date.parse('2012-07-14'), issue.due_date

511

end

511

end

512

513

def test_safe_attributes_should_not_include_readonly_fields

513

def test_safe_attributes_should_not_include_readonly_fields

514

WorkflowPermission.delete_all

514

WorkflowPermission.delete_all

515

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

515

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

516

:role_id => 1, :field_name => 'due_date',

516

:role_id => 1, :field_name => 'due_date',

517

:rule => 'readonly')

517

:rule => 'readonly')

518

user = User.find(2)

518

user = User.find(2)

519

520

issue = Issue.new(:project_id => 1, :tracker_id => 1)

520

issue = Issue.new(:project_id => 1, :tracker_id => 1)

521

assert_equal %w(due_date), issue.read_only_attribute_names(user)

521

assert_equal %w(due_date), issue.read_only_attribute_names(user)

522

assert_not_include 'due_date', issue.safe_attribute_names(user)

522

assert_not_include 'due_date', issue.safe_attribute_names(user)

523

524

issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user

524

issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user

525

assert_equal Date.parse('2012-07-14'), issue.start_date

525

assert_equal Date.parse('2012-07-14'), issue.start_date

526

assert_nil issue.due_date

526

assert_nil issue.due_date

527

end

527

end

528

529

def test_safe_attributes_should_not_include_readonly_custom_fields

529

def test_safe_attributes_should_not_include_readonly_custom_fields

530

cf1 = IssueCustomField.create!(:name => 'Writable field',

530

cf1 = IssueCustomField.create!(:name => 'Writable field',

531

:field_format => 'string',

531

:field_format => 'string',

532

:is_for_all => true, :tracker_ids => [1])

532

:is_for_all => true, :tracker_ids => [1])

533

cf2 = IssueCustomField.create!(:name => 'Readonly field',

533

cf2 = IssueCustomField.create!(:name => 'Readonly field',

534

:field_format => 'string',

534

:field_format => 'string',

535

:is_for_all => true, :tracker_ids => [1])

535

:is_for_all => true, :tracker_ids => [1])

536

WorkflowPermission.delete_all

536

WorkflowPermission.delete_all

537

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

537

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

538

:role_id => 1, :field_name => cf2.id.to_s,

538

:role_id => 1, :field_name => cf2.id.to_s,

539

:rule => 'readonly')

539

:rule => 'readonly')

540

user = User.find(2)

540

user = User.find(2)

541

issue = Issue.new(:project_id => 1, :tracker_id => 1)

541

issue = Issue.new(:project_id => 1, :tracker_id => 1)

542

assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)

542

assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)

543

assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)

543

assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)

544

545

issue.send :safe_attributes=, {'custom_field_values' => {

545

issue.send :safe_attributes=, {'custom_field_values' => {

546

cf1.id.to_s => 'value1', cf2.id.to_s => 'value2'

546

cf1.id.to_s => 'value1', cf2.id.to_s => 'value2'

547

}}, user

547

}}, user

548

assert_equal 'value1', issue.custom_field_value(cf1)

548

assert_equal 'value1', issue.custom_field_value(cf1)

549

assert_nil issue.custom_field_value(cf2)

549

assert_nil issue.custom_field_value(cf2)

550

551

issue.send :safe_attributes=, {'custom_fields' => [

551

issue.send :safe_attributes=, {'custom_fields' => [

552

{'id' => cf1.id.to_s, 'value' => 'valuea'},

552

{'id' => cf1.id.to_s, 'value' => 'valuea'},

553

{'id' => cf2.id.to_s, 'value' => 'valueb'}

553

{'id' => cf2.id.to_s, 'value' => 'valueb'}

554

]}, user

554

]}, user

555

assert_equal 'valuea', issue.custom_field_value(cf1)

555

assert_equal 'valuea', issue.custom_field_value(cf1)

556

assert_nil issue.custom_field_value(cf2)

556

assert_nil issue.custom_field_value(cf2)

557

end

557

end

558

559

def test_editable_custom_field_values_should_return_non_readonly_custom_values

559

def test_editable_custom_field_values_should_return_non_readonly_custom_values

560

cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',

560

cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',

561

:is_for_all => true, :tracker_ids => [1, 2])

561

:is_for_all => true, :tracker_ids => [1, 2])

562

cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',

562

cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',

563

:is_for_all => true, :tracker_ids => [1, 2])

563

:is_for_all => true, :tracker_ids => [1, 2])

564

WorkflowPermission.delete_all

564

WorkflowPermission.delete_all

565

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,

565

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,

566

:field_name => cf2.id.to_s, :rule => 'readonly')

566

:field_name => cf2.id.to_s, :rule => 'readonly')

567

user = User.find(2)

567

user = User.find(2)

568

569

issue = Issue.new(:project_id => 1, :tracker_id => 1)

569

issue = Issue.new(:project_id => 1, :tracker_id => 1)

570

values = issue.editable_custom_field_values(user)

570

values = issue.editable_custom_field_values(user)

571

assert values.detect {|value| value.custom_field == cf1}

571

assert values.detect {|value| value.custom_field == cf1}

572

assert_nil values.detect {|value| value.custom_field == cf2}

572

assert_nil values.detect {|value| value.custom_field == cf2}

573

574

issue.tracker_id = 2

574

issue.tracker_id = 2

575

values = issue.editable_custom_field_values(user)

575

values = issue.editable_custom_field_values(user)

576

assert values.detect {|value| value.custom_field == cf1}

576

assert values.detect {|value| value.custom_field == cf1}

577

assert values.detect {|value| value.custom_field == cf2}

577

assert values.detect {|value| value.custom_field == cf2}

578

end

578

end

579

580

def test_safe_attributes_should_accept_target_tracker_writable_fields

580

def test_safe_attributes_should_accept_target_tracker_writable_fields

581

WorkflowPermission.delete_all

581

WorkflowPermission.delete_all

582

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

582

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

583

:role_id => 1, :field_name => 'due_date',

583

:role_id => 1, :field_name => 'due_date',

584

:rule => 'readonly')

584

:rule => 'readonly')

585

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

585

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

586

:role_id => 1, :field_name => 'start_date',

586

:role_id => 1, :field_name => 'start_date',

587

:rule => 'readonly')

587

:rule => 'readonly')

588

user = User.find(2)

588

user = User.find(2)

589

590

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

590

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

591

592

issue.send :safe_attributes=, {'start_date' => '2012-07-12',

592

issue.send :safe_attributes=, {'start_date' => '2012-07-12',

593

'due_date' => '2012-07-14'}, user

593

'due_date' => '2012-07-14'}, user

594

assert_equal Date.parse('2012-07-12'), issue.start_date

594

assert_equal Date.parse('2012-07-12'), issue.start_date

595

assert_nil issue.due_date

595

assert_nil issue.due_date

596

597

issue.send :safe_attributes=, {'start_date' => '2012-07-15',

597

issue.send :safe_attributes=, {'start_date' => '2012-07-15',

598

'due_date' => '2012-07-16',

598

'due_date' => '2012-07-16',

599

'tracker_id' => 2}, user

599

'tracker_id' => 2}, user

600

assert_equal Date.parse('2012-07-12'), issue.start_date

600

assert_equal Date.parse('2012-07-12'), issue.start_date

601

assert_equal Date.parse('2012-07-16'), issue.due_date

601

assert_equal Date.parse('2012-07-16'), issue.due_date

602

end

602

end

603

604

def test_safe_attributes_should_accept_target_status_writable_fields

604

def test_safe_attributes_should_accept_target_status_writable_fields

605

WorkflowPermission.delete_all

605

WorkflowPermission.delete_all

606

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

606

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

607

:role_id => 1, :field_name => 'due_date',

607

:role_id => 1, :field_name => 'due_date',

608

:rule => 'readonly')

608

:rule => 'readonly')

609

WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,

609

WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,

610

:role_id => 1, :field_name => 'start_date',

610

:role_id => 1, :field_name => 'start_date',

611

:rule => 'readonly')

611

:rule => 'readonly')

612

user = User.find(2)

612

user = User.find(2)

613

614

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

614

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

615

616

issue.send :safe_attributes=, {'start_date' => '2012-07-12',

616

issue.send :safe_attributes=, {'start_date' => '2012-07-12',

617

'due_date' => '2012-07-14'},

617

'due_date' => '2012-07-14'},

618

user

618

user

619

assert_equal Date.parse('2012-07-12'), issue.start_date

619

assert_equal Date.parse('2012-07-12'), issue.start_date

620

assert_nil issue.due_date

620

assert_nil issue.due_date

621

622

issue.send :safe_attributes=, {'start_date' => '2012-07-15',

622

issue.send :safe_attributes=, {'start_date' => '2012-07-15',

623

'due_date' => '2012-07-16',

623

'due_date' => '2012-07-16',

624

'status_id' => 2},

624

'status_id' => 2},

625

user

625

user

626

assert_equal Date.parse('2012-07-12'), issue.start_date

626

assert_equal Date.parse('2012-07-12'), issue.start_date

627

assert_equal Date.parse('2012-07-16'), issue.due_date

627

assert_equal Date.parse('2012-07-16'), issue.due_date

628

end

628

end

629

630

def test_required_attributes_should_be_validated

630

def test_required_attributes_should_be_validated

631

cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string',

631

cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string',

632

:is_for_all => true, :tracker_ids => [1, 2])

632

:is_for_all => true, :tracker_ids => [1, 2])

633

634

WorkflowPermission.delete_all

634

WorkflowPermission.delete_all

635

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

635

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

636

:role_id => 1, :field_name => 'due_date',

636

:role_id => 1, :field_name => 'due_date',

637

:rule => 'required')

637

:rule => 'required')

638

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

638

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

639

:role_id => 1, :field_name => 'category_id',

639

:role_id => 1, :field_name => 'category_id',

640

:rule => 'required')

640

:rule => 'required')

641

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

641

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

642

:role_id => 1, :field_name => cf.id.to_s,

642

:role_id => 1, :field_name => cf.id.to_s,

643

:rule => 'required')

643

:rule => 'required')

644

645

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

645

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

646

:role_id => 1, :field_name => 'start_date',

646

:role_id => 1, :field_name => 'start_date',

647

:rule => 'required')

647

:rule => 'required')

648

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

648

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,

649

:role_id => 1, :field_name => cf.id.to_s,

649

:role_id => 1, :field_name => cf.id.to_s,

650

:rule => 'required')

650

:rule => 'required')

651

user = User.find(2)

651

user = User.find(2)

652

653

issue = Issue.new(:project_id => 1, :tracker_id => 1,

653

issue = Issue.new(:project_id => 1, :tracker_id => 1,

654

:status_id => 1, :subject => 'Required fields',

654

:status_id => 1, :subject => 'Required fields',

655

:author => user)

655

:author => user)

656

assert_equal [cf.id.to_s, "category_id", "due_date"],

656

assert_equal [cf.id.to_s, "category_id", "due_date"],

657

issue.required_attribute_names(user).sort

657

issue.required_attribute_names(user).sort

658

assert !issue.save, "Issue was saved"

658

assert !issue.save, "Issue was saved"

659

assert_equal ["Category can't be blank", "Due date can't be blank", "Foo can't be blank"],

659

assert_equal ["Category can't be blank", "Due date can't be blank", "Foo can't be blank"],

660

issue.errors.full_messages.sort

660

issue.errors.full_messages.sort

661

662

issue.tracker_id = 2

662

issue.tracker_id = 2

663

assert_equal [cf.id.to_s, "start_date"], issue.required_attribute_names(user).sort

663

assert_equal [cf.id.to_s, "start_date"], issue.required_attribute_names(user).sort

664

assert !issue.save, "Issue was saved"

664

assert !issue.save, "Issue was saved"

665

assert_equal ["Foo can't be blank", "Start date can't be blank"],

665

assert_equal ["Foo can't be blank", "Start date can't be blank"],

666

issue.errors.full_messages.sort

666

issue.errors.full_messages.sort

667

668

issue.start_date = Date.today

668

issue.start_date = Date.today

669

issue.custom_field_values = {cf.id.to_s => 'bar'}

669

issue.custom_field_values = {cf.id.to_s => 'bar'}

670

assert issue.save

670

assert issue.save

671

end

671

end

672

673

def test_required_attribute_names_for_multiple_roles_should_intersect_rules

673

def test_required_attribute_names_for_multiple_roles_should_intersect_rules

674

WorkflowPermission.delete_all

674

WorkflowPermission.delete_all

675

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, ~~:role_id~~ => 1, ~~:field_name~~ => ~~'due_date'~~, ~~:rule~~ => ~~'required'~~)

675

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

676

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'start_date', :rule => 'required')

676

:role_id => 1, :field_name => 'due_date',

677

:rule => 'required')

678

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

679

:role_id => 1, :field_name => 'start_date',

680

:rule => 'required')

677

user = User.find(2)

681

user = User.find(2)

678

member = Member.find(1)

682

member = Member.find(1)

679

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

683

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

680

684

681

assert_equal %w(due_date start_date), issue.required_attribute_names(user).sort

685

assert_equal %w(due_date start_date), issue.required_attribute_names(user).sort

682

686

683

member.role_ids = [1, 2]

687

member.role_ids = [1, 2]

684

member.save!

688

member.save!

685

assert_equal [], issue.required_attribute_names(user.reload)

689

assert_equal [], issue.required_attribute_names(user.reload)

686

690

687

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, ~~:role_id~~ => 2, ~~:field_name~~ => ~~'due_date'~~, ~~:rule~~ => ~~'required'~~)

691

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

692

:role_id => 2, :field_name => 'due_date',

693

:rule => 'required')

688

assert_equal %w(due_date), issue.required_attribute_names(user)

694

assert_equal %w(due_date), issue.required_attribute_names(user)

689

695

690

member.role_ids = [1, 2, 3]

696

member.role_ids = [1, 2, 3]

691

member.save!

697

member.save!

692

assert_equal [], issue.required_attribute_names(user.reload)

698

assert_equal [], issue.required_attribute_names(user.reload)

693

699

694

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, ~~:role_id~~ => 2, ~~:field_name~~ => ~~'due_date'~~, ~~:rule~~ => ~~'readonly'~~)

700

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,

701

:role_id => 2, :field_name => 'due_date',

702

:rule => 'readonly')

695

# required + readonly => required

703

# required + readonly => required

696

assert_equal %w(due_date), issue.required_attribute_names(user)

704

assert_equal %w(due_date), issue.required_attribute_names(user)

697

end

705

end

698

706

699

def test_read_only_attribute_names_for_multiple_roles_should_intersect_rules

707

def test_read_only_attribute_names_for_multiple_roles_should_intersect_rules

700

WorkflowPermission.delete_all

708

WorkflowPermission.delete_all

701

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'due_date', :rule => 'readonly')

709

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'due_date', :rule => 'readonly')

702

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'start_date', :rule => 'readonly')

710

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'start_date', :rule => 'readonly')

703

user = User.find(2)

711

user = User.find(2)

704

member = Member.find(1)

712

member = Member.find(1)

705

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

713

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)

706

714

707

assert_equal %w(due_date start_date), issue.read_only_attribute_names(user).sort

715

assert_equal %w(due_date start_date), issue.read_only_attribute_names(user).sort

708

716

709

member.role_ids = [1, 2]

717

member.role_ids = [1, 2]

710

member.save!

718

member.save!

711

assert_equal [], issue.read_only_attribute_names(user.reload)

719

assert_equal [], issue.read_only_attribute_names(user.reload)

712

720

713

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 2, :field_name => 'due_date', :rule => 'readonly')

721

WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 2, :field_name => 'due_date', :rule => 'readonly')

714

assert_equal %w(due_date), issue.read_only_attribute_names(user)

722

assert_equal %w(due_date), issue.read_only_attribute_names(user)

715

end

723

end

716

724

717

def test_copy

725

def test_copy

718

issue = Issue.new.copy_from(1)

726

issue = Issue.new.copy_from(1)

719

assert issue.copy?

727

assert issue.copy?

720

assert issue.save

728

assert issue.save

721

issue.reload

729

issue.reload

722

orig = Issue.find(1)

730

orig = Issue.find(1)

723

assert_equal orig.subject, issue.subject

731

assert_equal orig.subject, issue.subject

724

assert_equal orig.tracker, issue.tracker

732

assert_equal orig.tracker, issue.tracker

725

assert_equal "125", issue.custom_value_for(2).value

733

assert_equal "125", issue.custom_value_for(2).value

726

end

734

end

727

735

728

def test_copy_should_copy_status

736

def test_copy_should_copy_status

729

orig = Issue.find(8)

737

orig = Issue.find(8)

730

assert orig.status != IssueStatus.default

738

assert orig.status != IssueStatus.default

731

739

732

issue = Issue.new.copy_from(orig)

740

issue = Issue.new.copy_from(orig)

733

assert issue.save

741

assert issue.save

734

issue.reload

742

issue.reload

735

assert_equal orig.status, issue.status

743

assert_equal orig.status, issue.status

736

end

744

end

737

745

738

def test_copy_should_add_relation_with_copied_issue

746

def test_copy_should_add_relation_with_copied_issue

739

copied = Issue.find(1)

747

copied = Issue.find(1)

740

issue = Issue.new.copy_from(copied)

748

issue = Issue.new.copy_from(copied)

741

assert issue.save

749

assert issue.save

742

issue.reload

750

issue.reload

743

751

744

assert_equal 1, issue.relations.size

752

assert_equal 1, issue.relations.size

745

relation = issue.relations.first

753

relation = issue.relations.first

746

assert_equal 'copied_to', relation.relation_type

754

assert_equal 'copied_to', relation.relation_type

747

assert_equal copied, relation.issue_from

755

assert_equal copied, relation.issue_from

748

assert_equal issue, relation.issue_to

756

assert_equal issue, relation.issue_to

749

end

757

end

750

758

751

def test_copy_should_copy_subtasks

759

def test_copy_should_copy_subtasks

752

issue = Issue.generate_with_descendants!

760

issue = Issue.generate_with_descendants!

753

761

754

copy = issue.reload.copy

762

copy = issue.reload.copy

755

copy.author = User.find(7)

763

copy.author = User.find(7)

756

assert_difference 'Issue.count', 1+issue.descendants.count do

764

assert_difference 'Issue.count', 1+issue.descendants.count do

757

assert copy.save

765

assert copy.save

758

end

766

end

759

copy.reload

767

copy.reload

760

assert_equal %w(Child1 Child2), copy.children.map(&:subject).sort

768

assert_equal %w(Child1 Child2), copy.children.map(&:subject).sort

761

child_copy = copy.children.detect {|c| c.subject == 'Child1'}

769

child_copy = copy.children.detect {|c| c.subject == 'Child1'}

762

assert_equal %w(Child11), child_copy.children.map(&:subject).sort

770

assert_equal %w(Child11), child_copy.children.map(&:subject).sort

763

assert_equal copy.author, child_copy.author

771

assert_equal copy.author, child_copy.author

764

end

772

end

765

773

766

def test_copy_should_copy_subtasks_to_target_project

774

def test_copy_should_copy_subtasks_to_target_project

767

issue = Issue.generate_with_descendants!

775

issue = Issue.generate_with_descendants!

768

776

769

copy = issue.copy(:project_id => 3)

777

copy = issue.copy(:project_id => 3)

770

assert_difference 'Issue.count', 1+issue.descendants.count do

778

assert_difference 'Issue.count', 1+issue.descendants.count do

771

assert copy.save

779

assert copy.save

772

end

780

end

773

assert_equal [3], copy.reload.descendants.map(&:project_id).uniq

781

assert_equal [3], copy.reload.descendants.map(&:project_id).uniq

774

end

782

end

775

783

776

def test_copy_should_not_copy_subtasks_twice_when_saving_twice

784

def test_copy_should_not_copy_subtasks_twice_when_saving_twice

777

issue = Issue.generate_with_descendants!

785

issue = Issue.generate_with_descendants!

778

786

779

copy = issue.reload.copy

787

copy = issue.reload.copy

780

assert_difference 'Issue.count', 1+issue.descendants.count do

788

assert_difference 'Issue.count', 1+issue.descendants.count do

781

assert copy.save

789

assert copy.save

782

assert copy.save

790

assert copy.save

783

end

791

end

784

end

792

end

785

793

786

def test_should_not_call_after_project_change_on_creation

794

def test_should_not_call_after_project_change_on_creation

787

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1, :subject => 'Test', :author_id => 1)

795

issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1, :subject => 'Test', :author_id => 1)

788

issue.expects(:after_project_change).never

796

issue.expects(:after_project_change).never

789

issue.save!

797

issue.save!

790

end

798

end

791

799

792

def test_should_not_call_after_project_change_on_update

800

def test_should_not_call_after_project_change_on_update

793

issue = Issue.find(1)

801

issue = Issue.find(1)

794

issue.project = Project.find(1)

802

issue.project = Project.find(1)

795

issue.subject = 'No project change'

803

issue.subject = 'No project change'

796

issue.expects(:after_project_change).never

804

issue.expects(:after_project_change).never

797

issue.save!

805

issue.save!

798

end

806

end

799

807

800

def test_should_call_after_project_change_on_project_change

808

def test_should_call_after_project_change_on_project_change

801

issue = Issue.find(1)

809

issue = Issue.find(1)

802

issue.project = Project.find(2)

810

issue.project = Project.find(2)

803

issue.expects(:after_project_change).once

811

issue.expects(:after_project_change).once

804

issue.save!

812

issue.save!

805

end

813

end

806

814

807

def test_adding_journal_should_update_timestamp

815

def test_adding_journal_should_update_timestamp

808

issue = Issue.find(1)

816

issue = Issue.find(1)

809

updated_on_was = issue.updated_on

817

updated_on_was = issue.updated_on

810

818

811

issue.init_journal(User.first, "Adding notes")

819

issue.init_journal(User.first, "Adding notes")

812

assert_difference 'Journal.count' do

820

assert_difference 'Journal.count' do

813

assert issue.save

821

assert issue.save

814

end

822

end

815

issue.reload

823

issue.reload

816

824

817

assert_not_equal updated_on_was, issue.updated_on

825

assert_not_equal updated_on_was, issue.updated_on

818

end

826

end

819

827

820

def test_should_close_duplicates

828

def test_should_close_duplicates

821

# Create 3 issues

829

# Create 3 issues

822

issue1 = Issue.generate!

830

issue1 = Issue.generate!

823

issue2 = Issue.generate!

831

issue2 = Issue.generate!

824

issue3 = Issue.generate!

832

issue3 = Issue.generate!

825

833

826

# 2 is a dupe of 1

834

# 2 is a dupe of 1

827

IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

835

IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

828

# And 3 is a dupe of 2

836

# And 3 is a dupe of 2

829

IssueRelation.create!(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)

837

IssueRelation.create!(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)

830

# And 3 is a dupe of 1 (circular duplicates)

838

# And 3 is a dupe of 1 (circular duplicates)

831

IssueRelation.create!(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

839

IssueRelation.create!(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

832

840

833

assert issue1.reload.duplicates.include?(issue2)

841

assert issue1.reload.duplicates.include?(issue2)

834

842

835

# Closing issue 1

843

# Closing issue 1

836

issue1.init_journal(User.find(:first), "Closing issue1")

844

issue1.init_journal(User.find(:first), "Closing issue1")

837

issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}

845

issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}

838

assert issue1.save

846

assert issue1.save

839

# 2 and 3 should be also closed

847

# 2 and 3 should be also closed

840

assert issue2.reload.closed?

848

assert issue2.reload.closed?

841

assert issue3.reload.closed?

849

assert issue3.reload.closed?

842

end

850

end

843

851

844

def test_should_not_close_duplicated_issue

852

def test_should_not_close_duplicated_issue

845

issue1 = Issue.generate!

853

issue1 = Issue.generate!

846

issue2 = Issue.generate!

854

issue2 = Issue.generate!

847

855

848

# 2 is a dupe of 1

856

# 2 is a dupe of 1

849

IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

857

IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)

850

# 2 is a dup of 1 but 1 is not a duplicate of 2

858

# 2 is a dup of 1 but 1 is not a duplicate of 2

851

assert !issue2.reload.duplicates.include?(issue1)

859

assert !issue2.reload.duplicates.include?(issue1)

852

860

853

# Closing issue 2

861

# Closing issue 2

854

issue2.init_journal(User.find(:first), "Closing issue2")

862

issue2.init_journal(User.find(:first), "Closing issue2")

855

issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}

863

issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}

856

assert issue2.save

864

assert issue2.save

857

# 1 should not be also closed

865

# 1 should not be also closed

858

assert !issue1.reload.closed?

866

assert !issue1.reload.closed?

859

end

867

end

860

868

861

def test_assignable_versions

869

def test_assignable_versions

862

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')

870

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')

863

assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq

871

assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq

864

end

872

end

865

873

866

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

874

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

867

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')

875

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')

868

assert !issue.save

876

assert !issue.save

869

assert_not_nil issue.errors[:fixed_version_id]

877

assert_not_nil issue.errors[:fixed_version_id]

870

end

878

end

871

879

872

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

880

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

873

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')

881

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')

874

assert !issue.save

882

assert !issue.save

875

assert_not_nil issue.errors[:fixed_version_id]

883

assert_not_nil issue.errors[:fixed_version_id]

876

end

884

end

877

885

878

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

886

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

879

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

887

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,

880

:status_id => 1, :fixed_version_id => 3,

888

:status_id => 1, :fixed_version_id => 3,

881

:subject => 'New issue')

889

:subject => 'New issue')

882

assert issue.save

890

assert issue.save

883

end

891

end

884

892

885

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

893

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

886

issue = Issue.find(11)

894

issue = Issue.find(11)

887

assert_equal 'closed', issue.fixed_version.status

895

assert_equal 'closed', issue.fixed_version.status

888

issue.subject = 'Subject changed'

896

issue.subject = 'Subject changed'

889

assert issue.save

897

assert issue.save

890

end

898

end

891

899

892

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

900

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

893

issue = Issue.find(11)

901

issue = Issue.find(11)

894

issue.status_id = 1

902

issue.status_id = 1

895

assert !issue.save

903

assert !issue.save

896

assert_not_nil issue.errors[:base]

904

assert_not_nil issue.errors[:base]

897

end

905

end

898

906

899

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

907

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

900

issue = Issue.find(11)

908

issue = Issue.find(11)

901

issue.status_id = 1

909

issue.status_id = 1

902

issue.fixed_version_id = 3

910

issue.fixed_version_id = 3

903

assert issue.save

911

assert issue.save

904

end

912

end

905

913

906

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

914

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

907

issue = Issue.find(12)

915

issue = Issue.find(12)

908

assert_equal 'locked', issue.fixed_version.status

916

assert_equal 'locked', issue.fixed_version.status

909

issue.status_id = 1

917

issue.status_id = 1

910

assert issue.save

918

assert issue.save

911

end

919

end

912

920

913

def test_should_not_be_able_to_keep_unshared_version_when_changing_project

921

def test_should_not_be_able_to_keep_unshared_version_when_changing_project

914

issue = Issue.find(2)

922

issue = Issue.find(2)

915

assert_equal 2, issue.fixed_version_id

923

assert_equal 2, issue.fixed_version_id

916

issue.project_id = 3

924

issue.project_id = 3

917

assert_nil issue.fixed_version_id

925

assert_nil issue.fixed_version_id

918

issue.fixed_version_id = 2

926

issue.fixed_version_id = 2

919

assert !issue.save

927

assert !issue.save

920

assert_include 'Target version is not included in the list', issue.errors.full_messages

928

assert_include 'Target version is not included in the list', issue.errors.full_messages

921

end

929

end

922

930

923

def test_should_keep_shared_version_when_changing_project

931

def test_should_keep_shared_version_when_changing_project

924

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

932

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

925

933

926

issue = Issue.find(2)

934

issue = Issue.find(2)

927

assert_equal 2, issue.fixed_version_id

935

assert_equal 2, issue.fixed_version_id

928

issue.project_id = 3

936

issue.project_id = 3

929

assert_equal 2, issue.fixed_version_id

937

assert_equal 2, issue.fixed_version_id

930

assert issue.save

938

assert issue.save

931

end

939

end

932

940

933

def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled

941

def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled

934

assert_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))

942

assert_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))

935

end

943

end

936

944

937

def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled

945

def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled

938

Project.find(2).disable_module! :issue_tracking

946

Project.find(2).disable_module! :issue_tracking

939

assert_not_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))

947

assert_not_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))

940

end

948

end

941

949

942

def test_move_to_another_project_with_same_category

950

def test_move_to_another_project_with_same_category

943

issue = Issue.find(1)

951

issue = Issue.find(1)

944

issue.project = Project.find(2)

952

issue.project = Project.find(2)

945

assert issue.save

953

assert issue.save

946

issue.reload

954

issue.reload

947

assert_equal 2, issue.project_id

955

assert_equal 2, issue.project_id

948

# Category changes

956

# Category changes

949

assert_equal 4, issue.category_id

957

assert_equal 4, issue.category_id

950

# Make sure time entries were move to the target project

958

# Make sure time entries were move to the target project

951

assert_equal 2, issue.time_entries.first.project_id

959

assert_equal 2, issue.time_entries.first.project_id

952

end

960

end

953

961

954

def test_move_to_another_project_without_same_category

962

def test_move_to_another_project_without_same_category

955

issue = Issue.find(2)

963

issue = Issue.find(2)

956

issue.project = Project.find(2)

964

issue.project = Project.find(2)

957

assert issue.save

965

assert issue.save

958

issue.reload

966

issue.reload

959

assert_equal 2, issue.project_id

967

assert_equal 2, issue.project_id

960

# Category cleared

968

# Category cleared

961

assert_nil issue.category_id

969

assert_nil issue.category_id

962

end

970

end

963

971

964

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

972

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

965

issue = Issue.find(1)

973

issue = Issue.find(1)

966

issue.update_attribute(:fixed_version_id, 1)

974

issue.update_attribute(:fixed_version_id, 1)

967

issue.project = Project.find(2)

975

issue.project = Project.find(2)

968

assert issue.save

976

assert issue.save

969

issue.reload

977

issue.reload

970

assert_equal 2, issue.project_id

978

assert_equal 2, issue.project_id

971

# Cleared fixed_version

979

# Cleared fixed_version

972

assert_equal nil, issue.fixed_version

980

assert_equal nil, issue.fixed_version

973

end

981

end

974

982

975

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

983

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

976

issue = Issue.find(1)

984

issue = Issue.find(1)

977

issue.update_attribute(:fixed_version_id, 4)

985

issue.update_attribute(:fixed_version_id, 4)

978

issue.project = Project.find(5)

986

issue.project = Project.find(5)

979

assert issue.save

987

assert issue.save

980

issue.reload

988

issue.reload

981

assert_equal 5, issue.project_id

989

assert_equal 5, issue.project_id

982

# Keep fixed_version

990

# Keep fixed_version

983

assert_equal 4, issue.fixed_version_id

991

assert_equal 4, issue.fixed_version_id

984

end

992

end

985

993

986

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

994

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

987

issue = Issue.find(1)

995

issue = Issue.find(1)

988

issue.update_attribute(:fixed_version_id, 1)

996

issue.update_attribute(:fixed_version_id, 1)

989

issue.project = Project.find(5)

997

issue.project = Project.find(5)

990

assert issue.save

998

assert issue.save

991

issue.reload

999

issue.reload

992

assert_equal 5, issue.project_id

1000

assert_equal 5, issue.project_id

993

# Cleared fixed_version

1001

# Cleared fixed_version

994

assert_equal nil, issue.fixed_version

1002

assert_equal nil, issue.fixed_version

995

end

1003

end

996

1004

997

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

1005

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

998

issue = Issue.find(1)

1006

issue = Issue.find(1)

999

issue.update_attribute(:fixed_version_id, 7)

1007

issue.update_attribute(:fixed_version_id, 7)

1000

issue.project = Project.find(2)

1008

issue.project = Project.find(2)

1001

assert issue.save

1009

assert issue.save

1002

issue.reload

1010

issue.reload

1003

assert_equal 2, issue.project_id

1011

assert_equal 2, issue.project_id

1004

# Keep fixed_version

1012

# Keep fixed_version

1005

assert_equal 7, issue.fixed_version_id

1013

assert_equal 7, issue.fixed_version_id

1006

end

1014

end

1007

1015

1008

def test_move_to_another_project_should_keep_parent_if_valid

1016

def test_move_to_another_project_should_keep_parent_if_valid

1009

issue = Issue.find(1)

1017

issue = Issue.find(1)

1010

issue.update_attribute(:parent_issue_id, 2)

1018

issue.update_attribute(:parent_issue_id, 2)

1011

issue.project = Project.find(3)

1019

issue.project = Project.find(3)

1012

assert issue.save

1020

assert issue.save

1013

issue.reload

1021

issue.reload

1014

assert_equal 2, issue.parent_id

1022

assert_equal 2, issue.parent_id

1015

end

1023

end

1016

1024

1017

def test_move_to_another_project_should_clear_parent_if_not_valid

1025

def test_move_to_another_project_should_clear_parent_if_not_valid

1018

issue = Issue.find(1)

1026

issue = Issue.find(1)

1019

issue.update_attribute(:parent_issue_id, 2)

1027

issue.update_attribute(:parent_issue_id, 2)

1020

issue.project = Project.find(2)

1028

issue.project = Project.find(2)

1021

assert issue.save

1029

assert issue.save

1022

issue.reload

1030

issue.reload

1023

assert_nil issue.parent_id

1031

assert_nil issue.parent_id

1024

end

1032

end

1025

1033

1026

def test_move_to_another_project_with_disabled_tracker

1034

def test_move_to_another_project_with_disabled_tracker

1027

issue = Issue.find(1)

1035

issue = Issue.find(1)

1028

target = Project.find(2)

1036

target = Project.find(2)

1029

target.tracker_ids = [3]

1037

target.tracker_ids = [3]

1030

target.save

1038

target.save

1031

issue.project = target

1039

issue.project = target

1032

assert issue.save

1040

assert issue.save

1033

issue.reload

1041

issue.reload

1034

assert_equal 2, issue.project_id

1042

assert_equal 2, issue.project_id

1035

assert_equal 3, issue.tracker_id

1043

assert_equal 3, issue.tracker_id

1036

end

1044

end

1037

1045

1038

def test_copy_to_the_same_project

1046

def test_copy_to_the_same_project

1039

issue = Issue.find(1)

1047

issue = Issue.find(1)

1040

copy = issue.copy

1048

copy = issue.copy

1041

assert_difference 'Issue.count' do

1049

assert_difference 'Issue.count' do

1042

copy.save!

1050

copy.save!

1043

end

1051

end

1044

assert_kind_of Issue, copy

1052

assert_kind_of Issue, copy

1045

assert_equal issue.project, copy.project

1053

assert_equal issue.project, copy.project

1046

assert_equal "125", copy.custom_value_for(2).value

1054

assert_equal "125", copy.custom_value_for(2).value

1047

end

1055

end

1048

1056

1049

def test_copy_to_another_project_and_tracker

1057

def test_copy_to_another_project_and_tracker

1050

issue = Issue.find(1)

1058

issue = Issue.find(1)

1051

copy = issue.copy(:project_id => 3, :tracker_id => 2)

1059

copy = issue.copy(:project_id => 3, :tracker_id => 2)

1052

assert_difference 'Issue.count' do

1060

assert_difference 'Issue.count' do

1053

copy.save!

1061

copy.save!

1054

end

1062

end

1055

copy.reload

1063

copy.reload

1056

assert_kind_of Issue, copy

1064

assert_kind_of Issue, copy

1057

assert_equal Project.find(3), copy.project

1065

assert_equal Project.find(3), copy.project

1058

assert_equal Tracker.find(2), copy.tracker

1066

assert_equal Tracker.find(2), copy.tracker

1059

# Custom field #2 is not associated with target tracker

1067

# Custom field #2 is not associated with target tracker

1060

assert_nil copy.custom_value_for(2)

1068

assert_nil copy.custom_value_for(2)

1061

end

1069

end

1062

1070

1063

context "#copy" do

1071

context "#copy" do

1064

setup do

1072

setup do

1065

@issue = Issue.find(1)

1073

@issue = Issue.find(1)

1066

end

1074

end

1067

1075

1068

should "not create a journal" do

1076

should "not create a journal" do

1069

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)

1077

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)

1070

copy.save!

1078

copy.save!

1071

assert_equal 0, copy.reload.journals.size

1079

assert_equal 0, copy.reload.journals.size

1072

end

1080

end

1073

1081

1074

should "allow assigned_to changes" do

1082

should "allow assigned_to changes" do

1075

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)

1083

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)

1076

assert_equal 3, copy.assigned_to_id

1084

assert_equal 3, copy.assigned_to_id

1077

end

1085

end

1078

1086

1079

should "allow status changes" do

1087

should "allow status changes" do

1080

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)

1088

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)

1081

assert_equal 2, copy.status_id

1089

assert_equal 2, copy.status_id

1082

end

1090

end

1083

1091

1084

should "allow start date changes" do

1092

should "allow start date changes" do

1085

date = Date.today

1093

date = Date.today

1086

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)

1094

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)

1087

assert_equal date, copy.start_date

1095

assert_equal date, copy.start_date

1088

end

1096

end

1089

1097

1090

should "allow due date changes" do

1098

should "allow due date changes" do

1091

date = Date.today

1099

date = Date.today

1092

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)

1100

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)

1093

assert_equal date, copy.due_date

1101

assert_equal date, copy.due_date

1094

end

1102

end

1095

1103

1096

should "set current user as author" do

1104

should "set current user as author" do

1097

User.current = User.find(9)

1105

User.current = User.find(9)

1098

copy = @issue.copy(:project_id => 3, :tracker_id => 2)

1106

copy = @issue.copy(:project_id => 3, :tracker_id => 2)

1099

assert_equal User.current, copy.author

1107

assert_equal User.current, copy.author

1100

end

1108

end

1101

1109

1102

should "create a journal with notes" do

1110

should "create a journal with notes" do

1103

date = Date.today

1111

date = Date.today

1104

notes = "Notes added when copying"

1112

notes = "Notes added when copying"

1105

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)

1113

copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)

1106

copy.init_journal(User.current, notes)

1114

copy.init_journal(User.current, notes)

1107

copy.save!

1115

copy.save!

1108

1116

1109

assert_equal 1, copy.journals.size

1117

assert_equal 1, copy.journals.size

1110

journal = copy.journals.first

1118

journal = copy.journals.first

1111

assert_equal 0, journal.details.size

1119

assert_equal 0, journal.details.size

1112

assert_equal notes, journal.notes

1120

assert_equal notes, journal.notes

1113

end

1121

end

1114

end

1122

end

1115

1123

1116

def test_valid_parent_project

1124

def test_valid_parent_project

1117

issue = Issue.find(1)

1125

issue = Issue.find(1)

1118

issue_in_same_project = Issue.find(2)

1126

issue_in_same_project = Issue.find(2)

1119

issue_in_child_project = Issue.find(5)

1127

issue_in_child_project = Issue.find(5)

1120

issue_in_grandchild_project = Issue.generate!(:project_id => 6, :tracker_id => 1)

1128

issue_in_grandchild_project = Issue.generate!(:project_id => 6, :tracker_id => 1)

1121

issue_in_other_child_project = Issue.find(6)

1129

issue_in_other_child_project = Issue.find(6)

1122

issue_in_different_tree = Issue.find(4)

1130

issue_in_different_tree = Issue.find(4)

1123

1131

1124

with_settings :cross_project_subtasks => '' do

1132

with_settings :cross_project_subtasks => '' do

1125

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1133

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1126

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1134

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1127

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1135

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1128

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1136

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1129

end

1137

end

1130

1138

1131

with_settings :cross_project_subtasks => 'system' do

1139

with_settings :cross_project_subtasks => 'system' do

1132

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1140

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1133

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1141

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1134

assert_equal true, issue.valid_parent_project?(issue_in_different_tree)

1142

assert_equal true, issue.valid_parent_project?(issue_in_different_tree)

1135

end

1143

end

1136

1144

1137

with_settings :cross_project_subtasks => 'tree' do

1145

with_settings :cross_project_subtasks => 'tree' do

1138

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1146

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1139

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1147

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1140

assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)

1148

assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)

1141

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1149

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1142

1150

1143

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)

1151

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)

1144

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1152

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1145

end

1153

end

1146

1154

1147

with_settings :cross_project_subtasks => 'descendants' do

1155

with_settings :cross_project_subtasks => 'descendants' do

1148

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1156

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1149

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1157

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1150

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1158

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1151

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1159

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1152

1160

1153

assert_equal true, issue_in_child_project.valid_parent_project?(issue)

1161

assert_equal true, issue_in_child_project.valid_parent_project?(issue)

1154

assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1162

assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1155

end

1163

end

1156

end

1164

end

1157

1165

1158

def test_recipients_should_include_previous_assignee

1166

def test_recipients_should_include_previous_assignee

1159

user = User.find(3)

1167

user = User.find(3)

1160

user.members.update_all ["mail_notification = ?", false]

1168

user.members.update_all ["mail_notification = ?", false]

1161

user.update_attribute :mail_notification, 'only_assigned'

1169

user.update_attribute :mail_notification, 'only_assigned'

1162

1170

1163

issue = Issue.find(2)

1171

issue = Issue.find(2)

1164

issue.assigned_to = nil

1172

issue.assigned_to = nil

1165

assert_include user.mail, issue.recipients

1173

assert_include user.mail, issue.recipients

1166

issue.save!

1174

issue.save!

1167

assert !issue.recipients.include?(user.mail)

1175

assert !issue.recipients.include?(user.mail)

1168

end

1176

end

1169

1177

1170

def test_recipients_should_not_include_users_that_cannot_view_the_issue

1178

def test_recipients_should_not_include_users_that_cannot_view_the_issue

1171

issue = Issue.find(12)

1179

issue = Issue.find(12)

1172

assert issue.recipients.include?(issue.author.mail)

1180

assert issue.recipients.include?(issue.author.mail)

1173

# copy the issue to a private project

1181

# copy the issue to a private project

1174

copy = issue.copy(:project_id => 5, :tracker_id => 2)

1182

copy = issue.copy(:project_id => 5, :tracker_id => 2)

1175

# author is not a member of project anymore

1183

# author is not a member of project anymore

1176

assert !copy.recipients.include?(copy.author.mail)

1184

assert !copy.recipients.include?(copy.author.mail)

1177

end

1185

end

1178

1186

1179

def test_recipients_should_include_the_assigned_group_members

1187

def test_recipients_should_include_the_assigned_group_members

1180

group_member = User.generate!

1188

group_member = User.generate!

1181

group = Group.generate!

1189

group = Group.generate!

1182

group.users << group_member

1190

group.users << group_member

1183

1191

1184

issue = Issue.find(12)

1192

issue = Issue.find(12)

1185

issue.assigned_to = group

1193

issue.assigned_to = group

1186

assert issue.recipients.include?(group_member.mail)

1194

assert issue.recipients.include?(group_member.mail)

1187

end

1195

end

1188

1196

1189

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

1197

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

1190

user = User.find(3)

1198

user = User.find(3)

1191

issue = Issue.find(9)

1199

issue = Issue.find(9)

1192

Watcher.create!(:user => user, :watchable => issue)

1200

Watcher.create!(:user => user, :watchable => issue)

1193

assert issue.watched_by?(user)

1201

assert issue.watched_by?(user)

1194

assert !issue.watcher_recipients.include?(user.mail)

1202

assert !issue.watcher_recipients.include?(user.mail)

1195

end

1203

end

1196

1204

1197

def test_issue_destroy

1205

def test_issue_destroy

1198

Issue.find(1).destroy

1206

Issue.find(1).destroy

1199

assert_nil Issue.find_by_id(1)

1207

assert_nil Issue.find_by_id(1)

1200

assert_nil TimeEntry.find_by_issue_id(1)

1208

assert_nil TimeEntry.find_by_issue_id(1)

1201

end

1209

end

1202

1210

1203

def test_destroying_a_deleted_issue_should_not_raise_an_error

1211

def test_destroying_a_deleted_issue_should_not_raise_an_error

1204

issue = Issue.find(1)

1212

issue = Issue.find(1)

1205

Issue.find(1).destroy

1213

Issue.find(1).destroy

1206

1214

1207

assert_nothing_raised do

1215

assert_nothing_raised do

1208

assert_no_difference 'Issue.count' do

1216

assert_no_difference 'Issue.count' do

1209

issue.destroy

1217

issue.destroy

1210

end

1218

end

1211

assert issue.destroyed?

1219

assert issue.destroyed?

1212

end

1220

end

1213

end

1221

end

1214

1222

1215

def test_destroying_a_stale_issue_should_not_raise_an_error

1223

def test_destroying_a_stale_issue_should_not_raise_an_error

1216

issue = Issue.find(1)

1224

issue = Issue.find(1)

1217

Issue.find(1).update_attribute :subject, "Updated"

1225

Issue.find(1).update_attribute :subject, "Updated"

1218

1226

1219

assert_nothing_raised do

1227

assert_nothing_raised do

1220

assert_difference 'Issue.count', -1 do

1228

assert_difference 'Issue.count', -1 do

1221

issue.destroy

1229

issue.destroy

1222

end

1230

end

1223

assert issue.destroyed?

1231

assert issue.destroyed?

1224

end

1232

end

1225

end

1233

end

1226

1234

1227

def test_blocked

1235

def test_blocked

1228

blocked_issue = Issue.find(9)

1236

blocked_issue = Issue.find(9)

1229

blocking_issue = Issue.find(10)

1237

blocking_issue = Issue.find(10)

1230

1238

1231

assert blocked_issue.blocked?

1239

assert blocked_issue.blocked?

1232

assert !blocking_issue.blocked?

1240

assert !blocking_issue.blocked?

1233

end

1241

end

1234

1242

1235

def test_blocked_issues_dont_allow_closed_statuses

1243

def test_blocked_issues_dont_allow_closed_statuses

1236

blocked_issue = Issue.find(9)

1244

blocked_issue = Issue.find(9)

1237

1245

1238

allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))

1246

allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))

1239

assert !allowed_statuses.empty?

1247

assert !allowed_statuses.empty?

1240

closed_statuses = allowed_statuses.select {|st| st.is_closed?}

1248

closed_statuses = allowed_statuses.select {|st| st.is_closed?}

1241

assert closed_statuses.empty?

1249

assert closed_statuses.empty?

1242

end

1250

end

1243

1251

1244

def test_unblocked_issues_allow_closed_statuses

1252

def test_unblocked_issues_allow_closed_statuses

1245

blocking_issue = Issue.find(10)

1253

blocking_issue = Issue.find(10)

1246

1254

1247

allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))

1255

allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))

1248

assert !allowed_statuses.empty?

1256

assert !allowed_statuses.empty?

1249

closed_statuses = allowed_statuses.select {|st| st.is_closed?}

1257

closed_statuses = allowed_statuses.select {|st| st.is_closed?}

1250

assert !closed_statuses.empty?

1258

assert !closed_statuses.empty?

1251

end

1259

end

1252

1260

1253

def test_rescheduling_an_issue_should_reschedule_following_issue

1261

def test_rescheduling_an_issue_should_reschedule_following_issue

1254

issue1 = Issue.create!(:project_id => 1, :tracker_id => 1,

1262

issue1 = Issue.create!(:project_id => 1, :tracker_id => 1,

1255

:author_id => 1, :status_id => 1,

1263

:author_id => 1, :status_id => 1,

1256

:subject => '-',

1264

:subject => '-',

1257

:start_date => Date.today, :due_date => Date.today + 2)

1265

:start_date => Date.today, :due_date => Date.today + 2)

1258

issue2 = Issue.create!(:project_id => 1, :tracker_id => 1,

1266

issue2 = Issue.create!(:project_id => 1, :tracker_id => 1,

1259

:author_id => 1, :status_id => 1,

1267

:author_id => 1, :status_id => 1,

1260

:subject => '-',

1268

:subject => '-',

1261

:start_date => Date.today, :due_date => Date.today + 2)

1269

:start_date => Date.today, :due_date => Date.today + 2)

1262

IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,

1270

IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,

1263

:relation_type => IssueRelation::TYPE_PRECEDES)

1271

:relation_type => IssueRelation::TYPE_PRECEDES)

1264

assert_equal issue1.due_date + 1, issue2.reload.start_date

1272

assert_equal issue1.due_date + 1, issue2.reload.start_date

1265

1273

1266

issue1.due_date = Date.today + 5

1274

issue1.due_date = Date.today + 5

1267

issue1.save!

1275

issue1.save!

1268

assert_equal issue1.due_date + 1, issue2.reload.start_date

1276

assert_equal issue1.due_date + 1, issue2.reload.start_date

1269

end

1277

end

1270

1278

1271

def test_rescheduling_a_stale_issue_should_not_raise_an_error

1279

def test_rescheduling_a_stale_issue_should_not_raise_an_error

1272

stale = Issue.find(1)

1280

stale = Issue.find(1)

1273

issue = Issue.find(1)

1281

issue = Issue.find(1)

1274

issue.subject = "Updated"

1282

issue.subject = "Updated"

1275

issue.save!

1283

issue.save!

1276

1284

1277

date = 10.days.from_now.to_date

1285

date = 10.days.from_now.to_date

1278

assert_nothing_raised do

1286

assert_nothing_raised do

1279

stale.reschedule_after(date)

1287

stale.reschedule_after(date)

1280

end

1288

end

1281

assert_equal date, stale.reload.start_date

1289

assert_equal date, stale.reload.start_date

1282

end

1290

end

1283

1291

1284

def test_overdue

1292

def test_overdue

1285

assert Issue.new(:due_date => 1.day.ago.to_date).overdue?

1293

assert Issue.new(:due_date => 1.day.ago.to_date).overdue?

1286

assert !Issue.new(:due_date => Date.today).overdue?

1294

assert !Issue.new(:due_date => Date.today).overdue?

1287

assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?

1295

assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?

1288

assert !Issue.new(:due_date => nil).overdue?

1296

assert !Issue.new(:due_date => nil).overdue?

1289

assert !Issue.new(:due_date => 1.day.ago.to_date,

1297

assert !Issue.new(:due_date => 1.day.ago.to_date,

1290

:status => IssueStatus.find(:first,

1298

:status => IssueStatus.find(:first,

1291

:conditions => {:is_closed => true})

1299

:conditions => {:is_closed => true})

1292

).overdue?

1300

).overdue?

1293

end

1301

end

1294

1302

1295

context "#behind_schedule?" do

1303

context "#behind_schedule?" do

1296

should "be false if the issue has no start_date" do

1304

should "be false if the issue has no start_date" do

1297

assert !Issue.new(:start_date => nil,

1305

assert !Issue.new(:start_date => nil,

1298

:due_date => 1.day.from_now.to_date,

1306

:due_date => 1.day.from_now.to_date,

1299

:done_ratio => 0).behind_schedule?

1307

:done_ratio => 0).behind_schedule?

1300

end

1308

end

1301

1309

1302

should "be false if the issue has no end_date" do

1310

should "be false if the issue has no end_date" do

1303

assert !Issue.new(:start_date => 1.day.from_now.to_date,

1311

assert !Issue.new(:start_date => 1.day.from_now.to_date,

1304

:due_date => nil,

1312

:due_date => nil,

1305

:done_ratio => 0).behind_schedule?

1313

:done_ratio => 0).behind_schedule?

1306

end

1314

end

1307

1315

1308

should "be false if the issue has more done than it's calendar time" do

1316

should "be false if the issue has more done than it's calendar time" do

1309

assert !Issue.new(:start_date => 50.days.ago.to_date,

1317

assert !Issue.new(:start_date => 50.days.ago.to_date,

1310

:due_date => 50.days.from_now.to_date,

1318

:due_date => 50.days.from_now.to_date,

1311

:done_ratio => 90).behind_schedule?

1319

:done_ratio => 90).behind_schedule?

1312

end

1320

end

1313

1321

1314

should "be true if the issue hasn't been started at all" do

1322

should "be true if the issue hasn't been started at all" do

1315

assert Issue.new(:start_date => 1.day.ago.to_date,

1323

assert Issue.new(:start_date => 1.day.ago.to_date,

1316

:due_date => 1.day.from_now.to_date,

1324

:due_date => 1.day.from_now.to_date,

1317

:done_ratio => 0).behind_schedule?

1325

:done_ratio => 0).behind_schedule?

1318

end

1326

end

1319

1327

1320

should "be true if the issue has used more calendar time than it's done ratio" do

1328

should "be true if the issue has used more calendar time than it's done ratio" do

1321

assert Issue.new(:start_date => 100.days.ago.to_date,

1329

assert Issue.new(:start_date => 100.days.ago.to_date,

1322

:due_date => Date.today,

1330

:due_date => Date.today,

1323

:done_ratio => 90).behind_schedule?

1331

:done_ratio => 90).behind_schedule?

1324

end

1332

end

1325

end

1333

end

1326

1334

1327

context "#assignable_users" do

1335

context "#assignable_users" do

1328

should "be Users" do

1336

should "be Users" do

1329

assert_kind_of User, Issue.find(1).assignable_users.first

1337

assert_kind_of User, Issue.find(1).assignable_users.first

1330

end

1338

end

1331

1339

1332

should "include the issue author" do

1340

should "include the issue author" do

1333

non_project_member = User.generate!

1341

non_project_member = User.generate!

1334

issue = Issue.generate!(:author => non_project_member)

1342

issue = Issue.generate!(:author => non_project_member)

1335

1343

1336

assert issue.assignable_users.include?(non_project_member)

1344

assert issue.assignable_users.include?(non_project_member)

1337

end

1345

end

1338

1346

1339

should "include the current assignee" do

1347

should "include the current assignee" do

1340

user = User.generate!

1348

user = User.generate!

1341

issue = Issue.generate!(:assigned_to => user)

1349

issue = Issue.generate!(:assigned_to => user)

1342

user.lock!

1350

user.lock!

1343

1351

1344

assert Issue.find(issue.id).assignable_users.include?(user)

1352

assert Issue.find(issue.id).assignable_users.include?(user)

1345

end

1353

end

1346

1354

1347

should "not show the issue author twice" do

1355

should "not show the issue author twice" do

1348

assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)

1356

assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)

1349

assert_equal 2, assignable_user_ids.length

1357

assert_equal 2, assignable_user_ids.length

1350

1358

1351

assignable_user_ids.each do |user_id|

1359

assignable_user_ids.each do |user_id|

1352

assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,

1360

assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,

1353

"User #{user_id} appears more or less than once"

1361

"User #{user_id} appears more or less than once"

1354

end

1362

end

1355

end

1363

end

1356

1364

1357

context "with issue_group_assignment" do

1365

context "with issue_group_assignment" do

1358

should "include groups" do

1366

should "include groups" do

1359

issue = Issue.new(:project => Project.find(2))

1367

issue = Issue.new(:project => Project.find(2))

1360

1368

1361

with_settings :issue_group_assignment => '1' do

1369

with_settings :issue_group_assignment => '1' do

1362

assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort

1370

assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort

1363

assert issue.assignable_users.include?(Group.find(11))

1371

assert issue.assignable_users.include?(Group.find(11))

1364

end

1372

end

1365

end

1373

end

1366

end

1374

end

1367

1375

1368

context "without issue_group_assignment" do

1376

context "without issue_group_assignment" do

1369

should "not include groups" do

1377

should "not include groups" do

1370

issue = Issue.new(:project => Project.find(2))

1378

issue = Issue.new(:project => Project.find(2))

1371

1379

1372

with_settings :issue_group_assignment => '0' do

1380

with_settings :issue_group_assignment => '0' do

1373

assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort

1381

assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort

1374

assert !issue.assignable_users.include?(Group.find(11))

1382

assert !issue.assignable_users.include?(Group.find(11))

1375

end

1383

end

1376

end

1384

end

1377

end

1385

end

1378

end

1386

end

1379

1387

1380

def test_create_should_send_email_notification

1388

def test_create_should_send_email_notification

1381

ActionMailer::Base.deliveries.clear

1389

ActionMailer::Base.deliveries.clear

1382

issue = Issue.new(:project_id => 1, :tracker_id => 1,

1390

issue = Issue.new(:project_id => 1, :tracker_id => 1,

1383

:author_id => 3, :status_id => 1,

1391

:author_id => 3, :status_id => 1,

1384

:priority => IssuePriority.all.first,

1392

:priority => IssuePriority.all.first,

1385

:subject => 'test_create', :estimated_hours => '1:30')

1393

:subject => 'test_create', :estimated_hours => '1:30')

1386

1394

1387

assert issue.save

1395

assert issue.save

1388

assert_equal 1, ActionMailer::Base.deliveries.size

1396

assert_equal 1, ActionMailer::Base.deliveries.size

1389

end

1397

end

1390

1398

1391

def test_stale_issue_should_not_send_email_notification

1399

def test_stale_issue_should_not_send_email_notification

1392

ActionMailer::Base.deliveries.clear

1400

ActionMailer::Base.deliveries.clear

1393

issue = Issue.find(1)

1401

issue = Issue.find(1)

1394

stale = Issue.find(1)

1402

stale = Issue.find(1)

1395

1403

1396

issue.init_journal(User.find(1))

1404

issue.init_journal(User.find(1))

1397

issue.subject = 'Subjet update'

1405

issue.subject = 'Subjet update'

1398

assert issue.save

1406

assert issue.save

1399

assert_equal 1, ActionMailer::Base.deliveries.size

1407

assert_equal 1, ActionMailer::Base.deliveries.size

1400

ActionMailer::Base.deliveries.clear

1408

ActionMailer::Base.deliveries.clear

1401

1409

1402

stale.init_journal(User.find(1))

1410

stale.init_journal(User.find(1))

1403

stale.subject = 'Another subjet update'

1411

stale.subject = 'Another subjet update'

1404

assert_raise ActiveRecord::StaleObjectError do

1412

assert_raise ActiveRecord::StaleObjectError do

1405

stale.save

1413

stale.save

1406

end

1414

end

1407

assert ActionMailer::Base.deliveries.empty?

1415

assert ActionMailer::Base.deliveries.empty?

1408

end

1416

end

1409

1417

1410

def test_journalized_description

1418

def test_journalized_description

1411

IssueCustomField.delete_all

1419

IssueCustomField.delete_all

1412

1420

1413

i = Issue.first

1421

i = Issue.first

1414

old_description = i.description

1422

old_description = i.description

1415

new_description = "This is the new description"

1423

new_description = "This is the new description"

1416

1424

1417

i.init_journal(User.find(2))

1425

i.init_journal(User.find(2))

1418

i.description = new_description

1426

i.description = new_description

1419

assert_difference 'Journal.count', 1 do

1427

assert_difference 'Journal.count', 1 do

1420

assert_difference 'JournalDetail.count', 1 do

1428

assert_difference 'JournalDetail.count', 1 do

1421

i.save!

1429

i.save!

1422

end

1430

end

1423

end

1431

end

1424

1432

1425

detail = JournalDetail.first(:order => 'id DESC')

1433

detail = JournalDetail.first(:order => 'id DESC')

1426

assert_equal i, detail.journal.journalized

1434

assert_equal i, detail.journal.journalized

1427

assert_equal 'attr', detail.property

1435

assert_equal 'attr', detail.property

1428

assert_equal 'description', detail.prop_key

1436

assert_equal 'description', detail.prop_key

1429

assert_equal old_description, detail.old_value

1437

assert_equal old_description, detail.old_value

1430

assert_equal new_description, detail.value

1438

assert_equal new_description, detail.value

1431

end

1439

end

1432

1440

1433

def test_blank_descriptions_should_not_be_journalized

1441

def test_blank_descriptions_should_not_be_journalized

1434

IssueCustomField.delete_all

1442

IssueCustomField.delete_all

1435

Issue.update_all("description = NULL", "id=1")

1443

Issue.update_all("description = NULL", "id=1")

1436

1444

1437

i = Issue.find(1)

1445

i = Issue.find(1)

1438

i.init_journal(User.find(2))

1446

i.init_journal(User.find(2))

1439

i.subject = "blank description"

1447

i.subject = "blank description"

1440

i.description = "\r\n"

1448

i.description = "\r\n"

1441

1449

1442

assert_difference 'Journal.count', 1 do

1450

assert_difference 'Journal.count', 1 do

1443

assert_difference 'JournalDetail.count', 1 do

1451

assert_difference 'JournalDetail.count', 1 do

1444

i.save!

1452

i.save!

1445

end

1453

end

1446

end

1454

end

1447

end

1455

end

1448

1456

1449

def test_journalized_multi_custom_field

1457

def test_journalized_multi_custom_field

1450

field = IssueCustomField.create!(:name => 'filter', :field_format => 'list',

1458

field = IssueCustomField.create!(:name => 'filter', :field_format => 'list',

1451

:is_filter => true, :is_for_all => true,

1459

:is_filter => true, :is_for_all => true,

1452

:tracker_ids => [1],

1460

:tracker_ids => [1],

1453

:possible_values => ['value1', 'value2', 'value3'],

1461

:possible_values => ['value1', 'value2', 'value3'],

1454

:multiple => true)

1462

:multiple => true)

1455

1463

1456

issue = Issue.create!(:project_id => 1, :tracker_id => 1,

1464

issue = Issue.create!(:project_id => 1, :tracker_id => 1,

1457

:subject => 'Test', :author_id => 1)

1465

:subject => 'Test', :author_id => 1)

1458

1466

1459

assert_difference 'Journal.count' do

1467

assert_difference 'Journal.count' do

1460

assert_difference 'JournalDetail.count' do

1468

assert_difference 'JournalDetail.count' do

1461

issue.init_journal(User.first)

1469

issue.init_journal(User.first)

1462

issue.custom_field_values = {field.id => ['value1']}

1470

issue.custom_field_values = {field.id => ['value1']}

1463

issue.save!

1471

issue.save!

1464

end

1472

end

1465

assert_difference 'JournalDetail.count' do

1473

assert_difference 'JournalDetail.count' do

1466

issue.init_journal(User.first)

1474

issue.init_journal(User.first)

1467

issue.custom_field_values = {field.id => ['value1', 'value2']}

1475

issue.custom_field_values = {field.id => ['value1', 'value2']}

1468

issue.save!

1476

issue.save!

1469

end

1477

end

1470

assert_difference 'JournalDetail.count', 2 do

1478

assert_difference 'JournalDetail.count', 2 do

1471

issue.init_journal(User.first)

1479

issue.init_journal(User.first)

1472

issue.custom_field_values = {field.id => ['value3', 'value2']}

1480

issue.custom_field_values = {field.id => ['value3', 'value2']}

1473

issue.save!

1481

issue.save!

1474

end

1482

end

1475

assert_difference 'JournalDetail.count', 2 do

1483

assert_difference 'JournalDetail.count', 2 do

1476

issue.init_journal(User.first)

1484

issue.init_journal(User.first)

1477

issue.custom_field_values = {field.id => nil}

1485

issue.custom_field_values = {field.id => nil}

1478

issue.save!

1486

issue.save!

1479

end

1487

end

1480

end

1488

end

1481

end

1489

end

1482

1490

1483

def test_description_eol_should_be_normalized

1491

def test_description_eol_should_be_normalized

1484

i = Issue.new(:description => "CR \r LF \n CRLF \r\n")

1492

i = Issue.new(:description => "CR \r LF \n CRLF \r\n")

1485

assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description

1493

assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description

1486

end

1494

end

1487

1495

1488

def test_saving_twice_should_not_duplicate_journal_details

1496

def test_saving_twice_should_not_duplicate_journal_details

1489

i = Issue.find(:first)

1497

i = Issue.find(:first)

1490

i.init_journal(User.find(2), 'Some notes')

1498

i.init_journal(User.find(2), 'Some notes')

1491

# initial changes

1499

# initial changes

1492

i.subject = 'New subject'

1500

i.subject = 'New subject'

1493

i.done_ratio = i.done_ratio + 10

1501

i.done_ratio = i.done_ratio + 10

1494

assert_difference 'Journal.count' do

1502

assert_difference 'Journal.count' do

1495

assert i.save

1503

assert i.save

1496

end

1504

end

1497

# 1 more change

1505

# 1 more change

1498

i.priority = IssuePriority.find(:first, :conditions => ["id <> ?", i.priority_id])

1506

i.priority = IssuePriority.find(:first, :conditions => ["id <> ?", i.priority_id])

1499

assert_no_difference 'Journal.count' do

1507

assert_no_difference 'Journal.count' do

1500

assert_difference 'JournalDetail.count', 1 do

1508

assert_difference 'JournalDetail.count', 1 do

1501

i.save

1509

i.save

1502

end

1510

end

1503

end

1511

end

1504

# no more change

1512

# no more change

1505

assert_no_difference 'Journal.count' do

1513

assert_no_difference 'Journal.count' do

1506

assert_no_difference 'JournalDetail.count' do

1514

assert_no_difference 'JournalDetail.count' do

1507

i.save

1515

i.save

1508

end

1516

end

1509

end

1517

end

1510

end

1518

end

1511

1519

1512

def test_all_dependent_issues

1520

def test_all_dependent_issues

1513

IssueRelation.delete_all

1521

IssueRelation.delete_all

1514

assert IssueRelation.create!(:issue_from => Issue.find(1),

1522

assert IssueRelation.create!(:issue_from => Issue.find(1),

1515

:issue_to => Issue.find(2),

1523

:issue_to => Issue.find(2),

1516

:relation_type => IssueRelation::TYPE_PRECEDES)

1524

:relation_type => IssueRelation::TYPE_PRECEDES)

1517

assert IssueRelation.create!(:issue_from => Issue.find(2),

1525

assert IssueRelation.create!(:issue_from => Issue.find(2),

1518

:issue_to => Issue.find(3),

1526

:issue_to => Issue.find(3),

1519

:relation_type => IssueRelation::TYPE_PRECEDES)

1527

:relation_type => IssueRelation::TYPE_PRECEDES)

1520

assert IssueRelation.create!(:issue_from => Issue.find(3),

1528

assert IssueRelation.create!(:issue_from => Issue.find(3),

1521

:issue_to => Issue.find(8),

1529

:issue_to => Issue.find(8),

1522

:relation_type => IssueRelation::TYPE_PRECEDES)

1530

:relation_type => IssueRelation::TYPE_PRECEDES)

1523

1531

1524

assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort

1532

assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort

1525

end

1533

end

1526

1534

1527

def test_all_dependent_issues_with_persistent_circular_dependency

1535

def test_all_dependent_issues_with_persistent_circular_dependency

1528

IssueRelation.delete_all

1536

IssueRelation.delete_all

1529

assert IssueRelation.create!(:issue_from => Issue.find(1),

1537

assert IssueRelation.create!(:issue_from => Issue.find(1),

1530

:issue_to => Issue.find(2),

1538

:issue_to => Issue.find(2),

1531

:relation_type => IssueRelation::TYPE_PRECEDES)

1539

:relation_type => IssueRelation::TYPE_PRECEDES)

1532

assert IssueRelation.create!(:issue_from => Issue.find(2),

1540

assert IssueRelation.create!(:issue_from => Issue.find(2),

1533

:issue_to => Issue.find(3),

1541

:issue_to => Issue.find(3),

1534

:relation_type => IssueRelation::TYPE_PRECEDES)

1542

:relation_type => IssueRelation::TYPE_PRECEDES)

1535

1543

1536

r = IssueRelation.create!(:issue_from => Issue.find(3),

1544

r = IssueRelation.create!(:issue_from => Issue.find(3),

1537

:issue_to => Issue.find(7),

1545

:issue_to => Issue.find(7),

1538

:relation_type => IssueRelation::TYPE_PRECEDES)

1546

:relation_type => IssueRelation::TYPE_PRECEDES)

1539

IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])

1547

IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])

1540

1548

1541

assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort

1549

assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort

1542

end

1550

end

1543

1551

1544

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

1552

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

1545

IssueRelation.delete_all

1553

IssueRelation.delete_all

1546

assert IssueRelation.create!(:issue_from => Issue.find(1),

1554

assert IssueRelation.create!(:issue_from => Issue.find(1),

1547

:issue_to => Issue.find(2),

1555

:issue_to => Issue.find(2),

1548

:relation_type => IssueRelation::TYPE_RELATES)

1556

:relation_type => IssueRelation::TYPE_RELATES)

1549

assert IssueRelation.create!(:issue_from => Issue.find(2),

1557

assert IssueRelation.create!(:issue_from => Issue.find(2),

1550

:issue_to => Issue.find(3),

1558

:issue_to => Issue.find(3),

1551

:relation_type => IssueRelation::TYPE_RELATES)

1559

:relation_type => IssueRelation::TYPE_RELATES)

1552

assert IssueRelation.create!(:issue_from => Issue.find(3),

1560

assert IssueRelation.create!(:issue_from => Issue.find(3),

1553

:issue_to => Issue.find(8),

1561

:issue_to => Issue.find(8),

1554

:relation_type => IssueRelation::TYPE_RELATES)

1562

:relation_type => IssueRelation::TYPE_RELATES)

1555

1563

1556

r = IssueRelation.create!(:issue_from => Issue.find(8),

1564

r = IssueRelation.create!(:issue_from => Issue.find(8),

1557

:issue_to => Issue.find(7),

1565

:issue_to => Issue.find(7),

1558

:relation_type => IssueRelation::TYPE_RELATES)

1566

:relation_type => IssueRelation::TYPE_RELATES)

1559

IssueRelation.update_all("issue_to_id = 2", ["id = ?", r.id])

1567

IssueRelation.update_all("issue_to_id = 2", ["id = ?", r.id])

1560

1568

1561

r = IssueRelation.create!(:issue_from => Issue.find(3),

1569

r = IssueRelation.create!(:issue_from => Issue.find(3),

1562

:issue_to => Issue.find(7),

1570

:issue_to => Issue.find(7),

1563

:relation_type => IssueRelation::TYPE_RELATES)

1571

:relation_type => IssueRelation::TYPE_RELATES)

1564

IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])

1572

IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])

1565

1573

1566

assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort

1574

assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort

1567

end

1575

end

1568

1576

1569

context "#done_ratio" do

1577

context "#done_ratio" do

1570

setup do

1578

setup do

1571

@issue = Issue.find(1)

1579

@issue = Issue.find(1)

1572

@issue_status = IssueStatus.find(1)

1580

@issue_status = IssueStatus.find(1)

1573

@issue_status.update_attribute(:default_done_ratio, 50)

1581

@issue_status.update_attribute(:default_done_ratio, 50)

1574

@issue2 = Issue.find(2)

1582

@issue2 = Issue.find(2)

1575

@issue_status2 = IssueStatus.find(2)

1583

@issue_status2 = IssueStatus.find(2)

1576

@issue_status2.update_attribute(:default_done_ratio, 0)

1584

@issue_status2.update_attribute(:default_done_ratio, 0)

1577

end

1585

end

1578

1586

1579

teardown do

1587

teardown do

1580

Setting.issue_done_ratio = 'issue_field'

1588

Setting.issue_done_ratio = 'issue_field'

1581

end

1589

end

1582

1590

1583

context "with Setting.issue_done_ratio using the issue_field" do

1591

context "with Setting.issue_done_ratio using the issue_field" do

1584

setup do

1592

setup do

1585

Setting.issue_done_ratio = 'issue_field'

1593

Setting.issue_done_ratio = 'issue_field'

1586

end

1594

end

1587

1595

1588

should "read the issue's field" do

1596

should "read the issue's field" do

1589

assert_equal 0, @issue.done_ratio

1597

assert_equal 0, @issue.done_ratio

1590

assert_equal 30, @issue2.done_ratio

1598

assert_equal 30, @issue2.done_ratio

1591

end

1599

end

1592

end

1600

end

1593

1601

1594

context "with Setting.issue_done_ratio using the issue_status" do

1602

context "with Setting.issue_done_ratio using the issue_status" do

1595

setup do

1603

setup do

1596

Setting.issue_done_ratio = 'issue_status'

1604

Setting.issue_done_ratio = 'issue_status'

1597

end

1605

end

1598

1606

1599

should "read the Issue Status's default done ratio" do

1607

should "read the Issue Status's default done ratio" do

1600

assert_equal 50, @issue.done_ratio

1608

assert_equal 50, @issue.done_ratio

1601

assert_equal 0, @issue2.done_ratio

1609

assert_equal 0, @issue2.done_ratio

1602

end

1610

end

1603

end

1611

end

1604

end

1612

end

1605

1613

1606

context "#update_done_ratio_from_issue_status" do

1614

context "#update_done_ratio_from_issue_status" do

1607

setup do

1615

setup do

1608

@issue = Issue.find(1)

1616

@issue = Issue.find(1)

1609

@issue_status = IssueStatus.find(1)

1617

@issue_status = IssueStatus.find(1)

1610

@issue_status.update_attribute(:default_done_ratio, 50)

1618

@issue_status.update_attribute(:default_done_ratio, 50)

1611

@issue2 = Issue.find(2)

1619

@issue2 = Issue.find(2)

1612

@issue_status2 = IssueStatus.find(2)

1620

@issue_status2 = IssueStatus.find(2)

1613

@issue_status2.update_attribute(:default_done_ratio, 0)

1621

@issue_status2.update_attribute(:default_done_ratio, 0)

1614

end

1622

end

1615

1623

1616

context "with Setting.issue_done_ratio using the issue_field" do

1624

context "with Setting.issue_done_ratio using the issue_field" do

1617

setup do

1625

setup do

1618

Setting.issue_done_ratio = 'issue_field'

1626

Setting.issue_done_ratio = 'issue_field'

1619

end

1627

end

1620

1628

1621

should "not change the issue" do

1629

should "not change the issue" do

1622

@issue.update_done_ratio_from_issue_status

1630

@issue.update_done_ratio_from_issue_status

1623

@issue2.update_done_ratio_from_issue_status

1631

@issue2.update_done_ratio_from_issue_status

1624

1632

1625

assert_equal 0, @issue.read_attribute(:done_ratio)

1633

assert_equal 0, @issue.read_attribute(:done_ratio)

1626

assert_equal 30, @issue2.read_attribute(:done_ratio)

1634

assert_equal 30, @issue2.read_attribute(:done_ratio)

1627

end

1635

end

1628

end

1636

end

1629

1637

1630

context "with Setting.issue_done_ratio using the issue_status" do

1638

context "with Setting.issue_done_ratio using the issue_status" do

1631

setup do

1639

setup do

1632

Setting.issue_done_ratio = 'issue_status'

1640

Setting.issue_done_ratio = 'issue_status'

1633

end

1641

end

1634

1642

1635

should "change the issue's done ratio" do

1643

should "change the issue's done ratio" do

1636

@issue.update_done_ratio_from_issue_status

1644

@issue.update_done_ratio_from_issue_status

1637

@issue2.update_done_ratio_from_issue_status

1645

@issue2.update_done_ratio_from_issue_status

1638

1646

1639

assert_equal 50, @issue.read_attribute(:done_ratio)

1647

assert_equal 50, @issue.read_attribute(:done_ratio)

1640

assert_equal 0, @issue2.read_attribute(:done_ratio)

1648

assert_equal 0, @issue2.read_attribute(:done_ratio)

1641

end

1649

end

1642

end

1650

end

1643

end

1651

end

1644

1652

1645

test "#by_tracker" do

1653

test "#by_tracker" do

1646

User.current = User.anonymous

1654

User.current = User.anonymous

1647

groups = Issue.by_tracker(Project.find(1))

1655

groups = Issue.by_tracker(Project.find(1))

1648

assert_equal 3, groups.size

1656

assert_equal 3, groups.size

1649

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1657

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1650

end

1658

end

1651

1659

1652

test "#by_version" do

1660

test "#by_version" do

1653

User.current = User.anonymous

1661

User.current = User.anonymous

1654

groups = Issue.by_version(Project.find(1))

1662

groups = Issue.by_version(Project.find(1))

1655

assert_equal 3, groups.size

1663

assert_equal 3, groups.size

1656

assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1664

assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1657

end

1665

end

1658

1666

1659

test "#by_priority" do

1667

test "#by_priority" do

1660

User.current = User.anonymous

1668

User.current = User.anonymous

1661

groups = Issue.by_priority(Project.find(1))

1669

groups = Issue.by_priority(Project.find(1))

1662

assert_equal 4, groups.size

1670

assert_equal 4, groups.size

1663

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1671

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1664

end

1672

end

1665

1673

1666

test "#by_category" do

1674

test "#by_category" do

1667

User.current = User.anonymous

1675

User.current = User.anonymous

1668

groups = Issue.by_category(Project.find(1))

1676

groups = Issue.by_category(Project.find(1))

1669

assert_equal 2, groups.size

1677

assert_equal 2, groups.size

1670

assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1678

assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1671

end

1679

end

1672

1680

1673

test "#by_assigned_to" do

1681

test "#by_assigned_to" do

1674

User.current = User.anonymous

1682

User.current = User.anonymous

1675

groups = Issue.by_assigned_to(Project.find(1))

1683

groups = Issue.by_assigned_to(Project.find(1))

1676

assert_equal 2, groups.size

1684

assert_equal 2, groups.size

1677

assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1685

assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1678

end

1686

end

1679

1687

1680

test "#by_author" do

1688

test "#by_author" do

1681

User.current = User.anonymous

1689

User.current = User.anonymous

1682

groups = Issue.by_author(Project.find(1))

1690

groups = Issue.by_author(Project.find(1))

1683

assert_equal 4, groups.size

1691

assert_equal 4, groups.size

1684

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1692

assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1685

end

1693

end

1686

1694

1687

test "#by_subproject" do

1695

test "#by_subproject" do

1688

User.current = User.anonymous

1696

User.current = User.anonymous

1689

groups = Issue.by_subproject(Project.find(1))

1697

groups = Issue.by_subproject(Project.find(1))

1690

# Private descendant not visible

1698

# Private descendant not visible

1691

assert_equal 1, groups.size

1699

assert_equal 1, groups.size

1692

assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1700

assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}

1693

end

1701

end

1694

1702

1695

def test_recently_updated_scope

1703

def test_recently_updated_scope

1696

#should return the last updated issue

1704

#should return the last updated issue

1697

assert_equal Issue.reorder("updated_on DESC").first, Issue.recently_updated.limit(1).first

1705

assert_equal Issue.reorder("updated_on DESC").first, Issue.recently_updated.limit(1).first

1698

end

1706

end

1699

1707

1700

def test_on_active_projects_scope

1708

def test_on_active_projects_scope

1701

assert Project.find(2).archive

1709

assert Project.find(2).archive

1702

1710

1703

before = Issue.on_active_project.length

1711

before = Issue.on_active_project.length

1704

# test inclusion to results

1712

# test inclusion to results

1705

issue = Issue.generate!(:tracker => Project.find(2).trackers.first)

1713

issue = Issue.generate!(:tracker => Project.find(2).trackers.first)

1706

assert_equal before + 1, Issue.on_active_project.length

1714

assert_equal before + 1, Issue.on_active_project.length

1707

1715

1708

# Move to an archived project

1716

# Move to an archived project

1709

issue.project = Project.find(2)

1717

issue.project = Project.find(2)

1710

assert issue.save

1718

assert issue.save

1711

assert_equal before, Issue.on_active_project.length

1719

assert_equal before, Issue.on_active_project.length

1712

end

1720

end

1713

1721

1714

context "Issue#recipients" do

1722

context "Issue#recipients" do

1715

setup do

1723

setup do

1716

@project = Project.find(1)

1724

@project = Project.find(1)

1717

@author = User.generate!

1725

@author = User.generate!

1718

@assignee = User.generate!

1726

@assignee = User.generate!

1719

@issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)

1727

@issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)

1720

end

1728

end

1721

1729

1722

should "include project recipients" do

1730

should "include project recipients" do

1723

assert @project.recipients.present?

1731

assert @project.recipients.present?

1724

@project.recipients.each do |project_recipient|

1732

@project.recipients.each do |project_recipient|

1725

assert @issue.recipients.include?(project_recipient)

1733

assert @issue.recipients.include?(project_recipient)

1726

end

1734

end

1727

end

1735

end

1728

1736

1729

should "include the author if the author is active" do

1737

should "include the author if the author is active" do

1730

assert @issue.author, "No author set for Issue"

1738

assert @issue.author, "No author set for Issue"

1731

assert @issue.recipients.include?(@issue.author.mail)

1739

assert @issue.recipients.include?(@issue.author.mail)

1732

end

1740

end

1733

1741

1734

should "include the assigned to user if the assigned to user is active" do

1742

should "include the assigned to user if the assigned to user is active" do

1735

assert @issue.assigned_to, "No assigned_to set for Issue"

1743

assert @issue.assigned_to, "No assigned_to set for Issue"

1736

assert @issue.recipients.include?(@issue.assigned_to.mail)

1744

assert @issue.recipients.include?(@issue.assigned_to.mail)

1737

end

1745

end

1738

1746

1739

should "not include users who opt out of all email" do

1747

should "not include users who opt out of all email" do

1740

@author.update_attribute(:mail_notification, :none)

1748

@author.update_attribute(:mail_notification, :none)

1741

1749

1742

assert !@issue.recipients.include?(@issue.author.mail)

1750

assert !@issue.recipients.include?(@issue.author.mail)

1743

end

1751

end

1744

1752

1745

should "not include the issue author if they are only notified of assigned issues" do

1753

should "not include the issue author if they are only notified of assigned issues" do

1746

@author.update_attribute(:mail_notification, :only_assigned)

1754

@author.update_attribute(:mail_notification, :only_assigned)

1747

1755

1748

assert !@issue.recipients.include?(@issue.author.mail)

1756

assert !@issue.recipients.include?(@issue.author.mail)

1749

end

1757

end

1750

1758

1751

should "not include the assigned user if they are only notified of owned issues" do

1759

should "not include the assigned user if they are only notified of owned issues" do

1752

@assignee.update_attribute(:mail_notification, :only_owner)

1760

@assignee.update_attribute(:mail_notification, :only_owner)

1753

1761

1754

assert !@issue.recipients.include?(@issue.assigned_to.mail)

1762

assert !@issue.recipients.include?(@issue.assigned_to.mail)

1755

end

1763

end

1756

end

1764

end

1757

1765

1758

def test_last_journal_id_with_journals_should_return_the_journal_id

1766

def test_last_journal_id_with_journals_should_return_the_journal_id

1759

assert_equal 2, Issue.find(1).last_journal_id

1767

assert_equal 2, Issue.find(1).last_journal_id

1760

end

1768

end

1761

1769

1762

def test_last_journal_id_without_journals_should_return_nil

1770

def test_last_journal_id_without_journals_should_return_nil

1763

assert_nil Issue.find(3).last_journal_id

1771

assert_nil Issue.find(3).last_journal_id

1764

end

1772

end

1765

1773

1766

def test_journals_after_should_return_journals_with_greater_id

1774

def test_journals_after_should_return_journals_with_greater_id

1767

assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')

1775

assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')

1768

assert_equal [], Issue.find(1).journals_after('2')

1776

assert_equal [], Issue.find(1).journals_after('2')

1769

end

1777

end

1770

1778

1771

def test_journals_after_with_blank_arg_should_return_all_journals

1779

def test_journals_after_with_blank_arg_should_return_all_journals

1772

assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')

1780

assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')

1773

end

1781

end

1774

end

1782

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-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # 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 IssueTest < ActiveSupport::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles,
                        :groups_users,
                        :trackers, :projects_trackers,
                        :enabled_modules,
                        :versions,
                        :issue_statuses, :issue_categories, :issue_relations, :workflows,
                        :enumerations,
                        :issues, :journals, :journal_details,
                        :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                        :time_entries
               include Redmine::I18n
               def teardown
                 User.current = nil
               end
               def test_create
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                   :status_id => 1, :priority => IssuePriority.all.first,
                                   :subject => 'test_create',
                                   :description => 'IssueTest#test_create', :estimated_hours => '1:30')
                 assert issue.save
                 issue.reload
                 assert_equal 1.5, issue.estimated_hours
               end
               def test_create_minimal
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                   :status_id => 1, :priority => IssuePriority.all.first,
                                   :subject => 'test_create')
                 assert issue.save
                 assert issue.description.nil?
                 assert_nil issue.estimated_hours
               end
               def test_create_with_required_custom_field
                 set_language_if_valid 'en'
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :subject => 'test_create',
                                   :description => 'IssueTest#test_create_with_required_custom_field')
                 assert issue.available_custom_fields.include?(field)
                 # No value for the custom field
                 assert !issue.save
                 assert_equal ["Database can't be blank"], issue.errors.full_messages
                 # Blank value
                 issue.custom_field_values = { field.id => '' }
                 assert !issue.save
                 assert_equal ["Database can't be blank"], issue.errors.full_messages
                 # Invalid value
                 issue.custom_field_values = { field.id => 'SQLServer' }
                 assert !issue.save
                 assert_equal ["Database is not included in the list"], issue.errors.full_messages
                 # Valid value
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 issue.reload
                 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
               end
               def test_create_with_group_assignment
                 with_settings :issue_group_assignment => '1' do
                   assert Issue.new(:project_id => 2, :tracker_id => 1, :author_id => 1,
                                    :subject => 'Group assignment',
                                    :assigned_to_id => 11).save
                   issue = Issue.first(:order => 'id DESC')
                   assert_kind_of Group, issue.assigned_to
                   assert_equal Group.find(11), issue.assigned_to
                 end
               end
               def test_create_with_parent_issue_id
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => 1)
                 assert_save issue
                 assert_equal 1, issue.parent_issue_id
                 assert_equal Issue.find(1), issue.parent
               end
               def test_create_with_sharp_parent_issue_id
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => "#1")
                 assert_save issue
                 assert_equal 1, issue.parent_issue_id
                 assert_equal Issue.find(1), issue.parent
               end
               def test_create_with_invalid_parent_issue_id
                 set_language_if_valid 'en'
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => '01ABC')
                 assert !issue.save
                 assert_equal '01ABC', issue.parent_issue_id
                 assert_include 'Parent task is invalid', issue.errors.full_messages
               end
               def test_create_with_invalid_sharp_parent_issue_id
                 set_language_if_valid 'en'
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 1, :subject => 'Group assignment',
                                   :parent_issue_id => '#01ABC')
                 assert !issue.save
                 assert_equal '#01ABC', issue.parent_issue_id
                 assert_include 'Parent task is invalid', issue.errors.full_messages
               end
               def assert_visibility_match(user, issues)
                 assert_equal issues.collect(&:id).sort, Issue.all.select {|issue| issue.visible?(user)}.collect(&:id).sort
               end
               def test_visible_scope_for_anonymous
                 # Anonymous user should see issues of public projects only
                 issues = Issue.visible(User.anonymous).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.project.is_public?}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match User.anonymous, issues
               end
               def test_visible_scope_for_anonymous_without_view_issues_permissions
                 # Anonymous user should not see issues without permission
                 Role.anonymous.remove_permission!(:view_issues)
                 issues = Issue.visible(User.anonymous).all
                 assert issues.empty?
                 assert_visibility_match User.anonymous, issues
               end
               def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_default
                 assert Role.anonymous.update_attribute(:issues_visibility, 'default')
                 issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                 assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                 assert !issue.visible?(User.anonymous)
               end
               def test_anonymous_should_not_see_private_issues_with_issues_visibility_set_to_own
                 assert Role.anonymous.update_attribute(:issues_visibility, 'own')
                 issue = Issue.generate!(:author => User.anonymous, :assigned_to => User.anonymous, :is_private => true)
                 assert_nil Issue.where(:id => issue.id).visible(User.anonymous).first
                 assert !issue.visible?(User.anonymous)
               end
               def test_visible_scope_for_non_member
                 user = User.find(9)
                 assert user.projects.empty?
                 # Non member user should see issues of public projects only
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| !issue.project.is_public?}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_non_member_with_own_issues_visibility
                 Role.non_member.update_attribute :issues_visibility, 'own'
                 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 9, :subject => 'Issue by non member')
                 user = User.find(9)
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.author != user}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_non_member_without_view_issues_permissions
                 # Non member user should not see issues without permission
                 Role.non_member.remove_permission!(:view_issues)
                 user = User.find(9)
                 assert user.projects.empty?
                 issues = Issue.visible(user).all
                 assert issues.empty?
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_member
                 user = User.find(9)
                 # User should see issues of projects for which he has view_issues permissions only
                 Role.non_member.remove_permission!(:view_issues)
                 Member.create!(:principal => user, :project_id => 3, :role_ids => [2])
                 issues = Issue.visible(user).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.project_id != 3}
                 assert_nil issues.detect {|issue| issue.is_private?}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_for_member_with_groups_should_return_assigned_issues
                 user = User.find(8)
                 assert user.groups.any?
                 Member.create!(:principal => user.groups.first, :project_id => 1, :role_ids => [2])
                 Role.non_member.remove_permission!(:view_issues)
                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                   :status_id => 1, :priority => IssuePriority.all.first,
                   :subject => 'Assignment test',
                   :assigned_to => user.groups.first,
                   :is_private => true)
                 Role.find(2).update_attribute :issues_visibility, 'default'
                 issues = Issue.visible(User.find(8)).all
                 assert issues.any?
                 assert issues.include?(issue)
                 Role.find(2).update_attribute :issues_visibility, 'own'
                 issues = Issue.visible(User.find(8)).all
                 assert issues.any?
                 assert issues.include?(issue)
               end
               def test_visible_scope_for_admin
                 user = User.find(1)
                 user.members.each(&:destroy)
                 assert user.projects.empty?
                 issues = Issue.visible(user).all
                 assert issues.any?
                 # Admin should see issues on private projects that he does not belong to
                 assert issues.detect {|issue| !issue.project.is_public?}
                 # Admin should see private issues of other users
                 assert issues.detect {|issue| issue.is_private? && issue.author != user}
                 assert_visibility_match user, issues
               end
               def test_visible_scope_with_project
                 project = Project.find(1)
                 issues = Issue.visible(User.find(2), :project => project).all
                 projects = issues.collect(&:project).uniq
                 assert_equal 1, projects.size
                 assert_equal project, projects.first
               end
               def test_visible_scope_with_project_and_subprojects
                 project = Project.find(1)
                 issues = Issue.visible(User.find(2), :project => project, :with_subprojects => true).all
                 projects = issues.collect(&:project).uniq
                 assert projects.size > 1
                 assert_equal [], projects.select {|p| !p.is_or_is_descendant_of?(project)}
               end
               def test_visible_and_nested_set_scopes
                 assert_equal 0, Issue.find(1).descendants.visible.all.size
               end
               def test_open_scope
                 issues = Issue.open.all
                 assert_nil issues.detect(&:closed?)
               end
               def test_open_scope_with_arg
                 issues = Issue.open(false).all
                 assert_equal issues, issues.select(&:closed?)
               end
               def test_errors_full_messages_should_include_custom_fields_errors
                 field = IssueCustomField.find_by_name('Database')
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :subject => 'test_create',
                                   :description => 'IssueTest#test_create_with_required_custom_field')
                 assert issue.available_custom_fields.include?(field)
                 # Invalid value
                 issue.custom_field_values = { field.id => 'SQLServer' }
                 assert !issue.valid?
                 assert_equal 1, issue.errors.full_messages.size
                 assert_equal "Database #{I18n.translate('activerecord.errors.messages.inclusion')}",
                              issue.errors.full_messages.first
               end
               def test_update_issue_with_required_custom_field
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 issue = Issue.find(1)
                 assert_nil issue.custom_value_for(field)
                 assert issue.available_custom_fields.include?(field)
                 # No change to custom values, issue can be saved
                 assert issue.save
                 # Blank value
                 issue.custom_field_values = { field.id => '' }
                 assert !issue.save
                 # Valid value
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 issue.reload
                 assert_equal 'PostgreSQL', issue.custom_value_for(field).value
               end
               def test_should_not_update_attributes_if_custom_fields_validation_fails
                 issue = Issue.find(1)
                 field = IssueCustomField.find_by_name('Database')
                 assert issue.available_custom_fields.include?(field)
                 issue.custom_field_values = { field.id => 'Invalid' }
                 issue.subject = 'Should be not be saved'
                 assert !issue.save
                 issue.reload
                 assert_equal "Can't print recipes", issue.subject
               end
               def test_should_not_recreate_custom_values_objects_on_update
                 field = IssueCustomField.find_by_name('Database')
                 issue = Issue.find(1)
                 issue.custom_field_values = { field.id => 'PostgreSQL' }
                 assert issue.save
                 custom_value = issue.custom_value_for(field)
                 issue.reload
                 issue.custom_field_values = { field.id => 'MySQL' }
                 assert issue.save
                 issue.reload
                 assert_equal custom_value.id, issue.custom_value_for(field).id
               end
               def test_should_not_update_custom_fields_on_changing_tracker_with_different_custom_fields
                 issue = Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                       :status_id => 1, :subject => 'Test',
                                       :custom_field_values => {'2' => 'Test'})
                 assert !Tracker.find(2).custom_field_ids.include?(2)
                 issue = Issue.find(issue.id)
                 issue.attributes = {:tracker_id => 2, :custom_field_values => {'1' => ''}}
                 issue = Issue.find(issue.id)
                 custom_value = issue.custom_value_for(2)
                 assert_not_nil custom_value
                 assert_equal 'Test', custom_value.value
               end
               def test_assigning_tracker_id_should_reload_custom_fields_values
                 issue = Issue.new(:project => Project.find(1))
                 assert issue.custom_field_values.empty?
                 issue.tracker_id = 1
                 assert issue.custom_field_values.any?
               end
               def test_assigning_attributes_should_assign_project_and_tracker_first
                 seq = sequence('seq')
                 issue = Issue.new
                 issue.expects(:project_id=).in_sequence(seq)
                 issue.expects(:tracker_id=).in_sequence(seq)
                 issue.expects(:subject=).in_sequence(seq)
                 issue.attributes = {:tracker_id => 2, :project_id => 1, :subject => 'Test'}
               end
               def test_assigning_tracker_and_custom_fields_should_assign_custom_fields
                 attributes = ActiveSupport::OrderedHash.new
                 attributes['custom_field_values'] = { '1' => 'MySQL' }
                 attributes['tracker_id'] = '1'
                 issue = Issue.new(:project => Project.find(1))
                 issue.attributes = attributes
                 assert_equal 'MySQL', issue.custom_field_value(1)
               end
               def test_should_update_issue_with_disabled_tracker
                 p = Project.find(1)
                 issue = Issue.find(1)
                 p.trackers.delete(issue.tracker)
                 assert !p.trackers.include?(issue.tracker)
                 issue.reload
                 issue.subject = 'New subject'
                 assert issue.save
               end
               def test_should_not_set_a_disabled_tracker
                 p = Project.find(1)
                 p.trackers.delete(Tracker.find(2))
                 issue = Issue.find(1)
                 issue.tracker_id = 2
                 issue.subject = 'New subject'
                 assert !issue.save
                 assert_not_nil issue.errors[:tracker_id]
               end
               def test_category_based_assignment
                 issue = Issue.create(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                      :status_id => 1, :priority => IssuePriority.all.first,
                                      :subject => 'Assignment test',
                                      :description => 'Assignment test', :category_id => 1)
                 assert_equal IssueCategory.find(1).assigned_to, issue.assigned_to
               end
               def test_new_statuses_allowed_to
                 WorkflowTransition.delete_all
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 2,
                                            :author => false, :assignee => false)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 3,
                                            :author => true, :assignee => false)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1,
                                            :new_status_id => 4, :author => false,
                                            :assignee => true)
                 WorkflowTransition.create!(:role_id => 1, :tracker_id => 1,
                                            :old_status_id => 1, :new_status_id => 5,
                                            :author => true, :assignee => true)
                 status = IssueStatus.find(1)
                 role = Role.find(1)
                 tracker = Tracker.find(1)
                 user = User.find(2)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author_id => 1)
                 assert_equal [1, 2], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author => user)
                 assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author_id => 1,
                                         :assigned_to => user)
                 assert_equal [1, 2, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status,
                                         :project_id => 1, :author => user,
                                         :assigned_to => user)
                 assert_equal [1, 2, 3, 4, 5], issue.new_statuses_allowed_to(user).map(&:id)
               end
               def test_new_statuses_allowed_to_should_return_all_transitions_for_admin
                 admin = User.find(1)
                 issue = Issue.find(1)
                 assert !admin.member_of?(issue.project)
                 expected_statuses = [issue.status] +
                                         WorkflowTransition.find_all_by_old_status_id(
                                             issue.status_id).map(&:new_status).uniq.sort
                 assert_equal expected_statuses, issue.new_statuses_allowed_to(admin)
               end
               def test_new_statuses_allowed_to_should_return_default_and_current_status_when_copying
                 issue = Issue.find(1).copy
                 assert_equal [1], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
                 issue = Issue.find(2).copy
                 assert_equal [1, 2], issue.new_statuses_allowed_to(User.find(2)).map(&:id)
               end
               def test_safe_attributes_names_should_not_include_disabled_field
                 tracker = Tracker.new(:core_fields => %w(assigned_to_id fixed_version_id))
                 issue = Issue.new(:tracker => tracker)
                 assert_include 'tracker_id', issue.safe_attribute_names
                 assert_include 'status_id', issue.safe_attribute_names
                 assert_include 'subject', issue.safe_attribute_names
                 assert_include 'description', issue.safe_attribute_names
                 assert_include 'custom_field_values', issue.safe_attribute_names
                 assert_include 'custom_fields', issue.safe_attribute_names
                 assert_include 'lock_version', issue.safe_attribute_names
                 tracker.core_fields.each do |field|
                   assert_include field, issue.safe_attribute_names
                 end
                 tracker.disabled_core_fields.each do |field|
                   assert_not_include field, issue.safe_attribute_names
                 end
               end
               def test_safe_attributes_should_ignore_disabled_fields
                 tracker = Tracker.find(1)
                 tracker.core_fields = %w(assigned_to_id due_date)
                 tracker.save!
                 issue = Issue.new(:tracker => tracker)
                 issue.safe_attributes = {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}
                 assert_nil issue.start_date
                 assert_equal Date.parse('2012-07-14'), issue.due_date
               end
               def test_safe_attributes_should_accept_target_tracker_enabled_fields
                 source = Tracker.find(1)
                 source.core_fields = []
                 source.save!
                 target = Tracker.find(2)
                 target.core_fields = %w(assigned_to_id due_date)
                 target.save!
                 issue = Issue.new(:tracker => source)
                 issue.safe_attributes = {'tracker_id' => 2, 'due_date' => '2012-07-14'}
                 assert_equal target, issue.tracker
                 assert_equal Date.parse('2012-07-14'), issue.due_date
               end
               def test_safe_attributes_should_not_include_readonly_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 assert_equal %w(due_date), issue.read_only_attribute_names(user)
                 assert_not_include 'due_date', issue.safe_attribute_names(user)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-14', 'due_date' => '2012-07-14'}, user
                 assert_equal Date.parse('2012-07-14'), issue.start_date
                 assert_nil issue.due_date
               end
               def test_safe_attributes_should_not_include_readonly_custom_fields
                 cf1 = IssueCustomField.create!(:name => 'Writable field',
                                                :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1])
                 cf2 = IssueCustomField.create!(:name => 'Readonly field',
                                                :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => cf2.id.to_s,
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 assert_equal [cf2.id.to_s], issue.read_only_attribute_names(user)
                 assert_not_include cf2.id.to_s, issue.safe_attribute_names(user)
                 issue.send :safe_attributes=, {'custom_field_values' => {
                                                    cf1.id.to_s => 'value1', cf2.id.to_s => 'value2'
                                                  }}, user
                 assert_equal 'value1', issue.custom_field_value(cf1)
                 assert_nil issue.custom_field_value(cf2)
                 issue.send :safe_attributes=, {'custom_fields' => [
                                                   {'id' => cf1.id.to_s, 'value' => 'valuea'},
                                                   {'id' => cf2.id.to_s, 'value' => 'valueb'}
                                                 ]}, user
                 assert_equal 'valuea', issue.custom_field_value(cf1)
                 assert_nil issue.custom_field_value(cf2)
               end
               def test_editable_custom_field_values_should_return_non_readonly_custom_values
                 cf1 = IssueCustomField.create!(:name => 'Writable field', :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1, 2])
                 cf2 = IssueCustomField.create!(:name => 'Readonly field', :field_format => 'string',
                                                :is_for_all => true, :tracker_ids => [1, 2])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1,
                                            :field_name => cf2.id.to_s, :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1)
                 values = issue.editable_custom_field_values(user)
                 assert values.detect {|value| value.custom_field == cf1}
                 assert_nil values.detect {|value| value.custom_field == cf2}
                 issue.tracker_id = 2
                 values = issue.editable_custom_field_values(user)
                 assert values.detect {|value| value.custom_field == cf1}
                 assert values.detect {|value| value.custom_field == cf2}
               end
               def test_safe_attributes_should_accept_target_tracker_writable_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                'due_date' => '2012-07-14'}, user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_nil issue.due_date
                 issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                'due_date' => '2012-07-16',
                                                'tracker_id' => 2}, user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_equal Date.parse('2012-07-16'), issue.due_date
               end
               def test_safe_attributes_should_accept_target_status_writable_fields
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 2, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'readonly')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 issue.send :safe_attributes=, {'start_date' => '2012-07-12',
                                                'due_date' => '2012-07-14'},
                                                user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_nil issue.due_date
                 issue.send :safe_attributes=, {'start_date' => '2012-07-15',
                                                 'due_date' => '2012-07-16',
                                                 'status_id' => 2},
                                               user
                 assert_equal Date.parse('2012-07-12'), issue.start_date
                 assert_equal Date.parse('2012-07-16'), issue.due_date
               end
               def test_required_attributes_should_be_validated
                 cf = IssueCustomField.create!(:name => 'Foo', :field_format => 'string',
                                               :is_for_all => true, :tracker_ids => [1, 2])
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'due_date',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => 'category_id',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
                                            :role_id => 1, :field_name => cf.id.to_s,
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => 'start_date',
                                            :rule => 'required')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 2,
                                            :role_id => 1, :field_name => cf.id.to_s,
                                            :rule => 'required')
                 user = User.find(2)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :status_id => 1, :subject => 'Required fields',
                                   :author => user)
                 assert_equal [cf.id.to_s, "category_id", "due_date"],
                              issue.required_attribute_names(user).sort
                 assert !issue.save, "Issue was saved"
                 assert_equal ["Category can't be blank", "Due date can't be blank", "Foo can't be blank"],
                               issue.errors.full_messages.sort
                 issue.tracker_id = 2
                 assert_equal [cf.id.to_s, "start_date"], issue.required_attribute_names(user).sort
                 assert !issue.save, "Issue was saved"
                 assert_equal ["Foo can't be blank", "Start date can't be blank"],
                              issue.errors.full_messages.sort
                 issue.start_date = Date.today
                 issue.custom_field_values = {cf.id.to_s => 'bar'}
                 assert issue.save
               end
               def test_required_attribute_names_for_multiple_roles_should_intersect_rules
                 WorkflowPermission.delete_all
-                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'due_date', :rule => 'required')
+                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
-                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'start_date', :rule => 'required')
+                                           :role_id => 1, :field_name => 'due_date',
+                                           :rule => 'required')
+                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
+                                           :role_id => 1, :field_name => 'start_date',
+                                           :rule => 'required')
                 user = User.find(2)
                 member = Member.find(1)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 assert_equal %w(due_date start_date), issue.required_attribute_names(user).sort
                 member.role_ids = [1, 2]
                 member.save!
                 assert_equal [], issue.required_attribute_names(user.reload)
-                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 2, :field_name => 'due_date', :rule => 'required')
+                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
+                                           :role_id => 2, :field_name => 'due_date',
+                                           :rule => 'required')
                 assert_equal %w(due_date), issue.required_attribute_names(user)
                 member.role_ids = [1, 2, 3]
                 member.save!
                 assert_equal [], issue.required_attribute_names(user.reload)
-                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 2, :field_name => 'due_date', :rule => 'readonly')
+                WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1,
+                                           :role_id => 2, :field_name => 'due_date',
+                                           :rule => 'readonly')
                 # required + readonly => required
                 assert_equal %w(due_date), issue.required_attribute_names(user)
               end
               def test_read_only_attribute_names_for_multiple_roles_should_intersect_rules
                 WorkflowPermission.delete_all
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'due_date', :rule => 'readonly')
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 1, :field_name => 'start_date', :rule => 'readonly')
                 user = User.find(2)
                 member = Member.find(1)
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1)
                 assert_equal %w(due_date start_date), issue.read_only_attribute_names(user).sort
                 member.role_ids = [1, 2]
                 member.save!
                 assert_equal [], issue.read_only_attribute_names(user.reload)
                 WorkflowPermission.create!(:old_status_id => 1, :tracker_id => 1, :role_id => 2, :field_name => 'due_date', :rule => 'readonly')
                 assert_equal %w(due_date), issue.read_only_attribute_names(user)
               end
               def test_copy
                 issue = Issue.new.copy_from(1)
                 assert issue.copy?
                 assert issue.save
                 issue.reload
                 orig = Issue.find(1)
                 assert_equal orig.subject, issue.subject
                 assert_equal orig.tracker, issue.tracker
                 assert_equal "125", issue.custom_value_for(2).value
               end
               def test_copy_should_copy_status
                 orig = Issue.find(8)
                 assert orig.status != IssueStatus.default
                 issue = Issue.new.copy_from(orig)
                 assert issue.save
                 issue.reload
                 assert_equal orig.status, issue.status
               end
               def test_copy_should_add_relation_with_copied_issue
                 copied = Issue.find(1)
                 issue = Issue.new.copy_from(copied)
                 assert issue.save
                 issue.reload
                 assert_equal 1, issue.relations.size
                 relation = issue.relations.first
                 assert_equal 'copied_to', relation.relation_type
                 assert_equal copied, relation.issue_from
                 assert_equal issue, relation.issue_to
               end
               def test_copy_should_copy_subtasks
                 issue = Issue.generate_with_descendants!
                 copy = issue.reload.copy
                 copy.author = User.find(7)
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                 end
                 copy.reload
                 assert_equal %w(Child1 Child2), copy.children.map(&:subject).sort
                 child_copy = copy.children.detect {|c| c.subject == 'Child1'}
                 assert_equal %w(Child11), child_copy.children.map(&:subject).sort
                 assert_equal copy.author, child_copy.author
               end
               def test_copy_should_copy_subtasks_to_target_project
                 issue = Issue.generate_with_descendants!
                 copy = issue.copy(:project_id => 3)
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                 end
                 assert_equal [3], copy.reload.descendants.map(&:project_id).uniq
               end
               def test_copy_should_not_copy_subtasks_twice_when_saving_twice
                 issue = Issue.generate_with_descendants!
                 copy = issue.reload.copy
                 assert_difference 'Issue.count', 1+issue.descendants.count do
                   assert copy.save
                   assert copy.save
                 end
               end
               def test_should_not_call_after_project_change_on_creation
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :status_id => 1, :subject => 'Test', :author_id => 1)
                 issue.expects(:after_project_change).never
                 issue.save!
               end
               def test_should_not_call_after_project_change_on_update
                 issue = Issue.find(1)
                 issue.project = Project.find(1)
                 issue.subject = 'No project change'
                 issue.expects(:after_project_change).never
                 issue.save!
               end
               def test_should_call_after_project_change_on_project_change
                 issue = Issue.find(1)
                 issue.project = Project.find(2)
                 issue.expects(:after_project_change).once
                 issue.save!
               end
               def test_adding_journal_should_update_timestamp
                 issue = Issue.find(1)
                 updated_on_was = issue.updated_on
                 issue.init_journal(User.first, "Adding notes")
                 assert_difference 'Journal.count' do
                   assert issue.save
                 end
                 issue.reload
                 assert_not_equal updated_on_was, issue.updated_on
               end
               def test_should_close_duplicates
                 # Create 3 issues
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 issue3 = Issue.generate!
                 # 2 is a dupe of 1
                 IssueRelation.create!(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 2
                 IssueRelation.create!(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 1 (circular duplicates)
                 IssueRelation.create!(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 assert issue1.reload.duplicates.include?(issue2)
                 # Closing issue 1
                 issue1.init_journal(User.find(:first), "Closing issue1")
                 issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                 assert issue1.save
                 # 2 and 3 should be also closed
                 assert issue2.reload.closed?
                 assert issue3.reload.closed?
               end
               def test_should_not_close_duplicated_issue
                 issue1 = Issue.generate!
                 issue2 = Issue.generate!
                 # 2 is a dupe of 1
                 IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # 2 is a dup of 1 but 1 is not a duplicate of 2
                 assert !issue2.reload.duplicates.include?(issue1)
                 # Closing issue 2
                 issue2.init_journal(User.find(:first), "Closing issue2")
                 issue2.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                 assert issue2.save
                 # 1 should not be also closed
                 assert !issue1.reload.closed?
               end
               def test_assignable_versions
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
                 assert_equal ['open'], issue.assignable_versions.collect(&:status).uniq
               end
               def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 1, :subject => 'New issue')
                 assert !issue.save
                 assert_not_nil issue.errors[:fixed_version_id]
               end
               def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :fixed_version_id => 2, :subject => 'New issue')
                 assert !issue.save
                 assert_not_nil issue.errors[:fixed_version_id]
               end
               def test_should_be_able_to_assign_a_new_issue_to_an_open_version
                 issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1,
                                   :status_id => 1, :fixed_version_id => 3,
                                   :subject => 'New issue')
                 assert issue.save
               end
               def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 assert_equal 'closed', issue.fixed_version.status
                 issue.subject = 'Subject changed'
                 assert issue.save
               end
               def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 issue.status_id = 1
                 assert !issue.save
                 assert_not_nil issue.errors[:base]
               end
               def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version
                 issue = Issue.find(11)
                 issue.status_id = 1
                 issue.fixed_version_id = 3
                 assert issue.save
               end
               def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version
                 issue = Issue.find(12)
                 assert_equal 'locked', issue.fixed_version.status
                 issue.status_id = 1
                 assert issue.save
               end
               def test_should_not_be_able_to_keep_unshared_version_when_changing_project
                 issue = Issue.find(2)
                 assert_equal 2, issue.fixed_version_id
                 issue.project_id = 3
                 assert_nil issue.fixed_version_id
                 issue.fixed_version_id = 2
                 assert !issue.save
                 assert_include 'Target version is not included in the list', issue.errors.full_messages
               end
               def test_should_keep_shared_version_when_changing_project
                 Version.find(2).update_attribute :sharing, 'tree'
                 issue = Issue.find(2)
                 assert_equal 2, issue.fixed_version_id
                 issue.project_id = 3
                 assert_equal 2, issue.fixed_version_id
                 assert issue.save
               end
               def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled
                 assert_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
               end
               def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled
                 Project.find(2).disable_module! :issue_tracking
                 assert_not_include Project.find(2), Issue.allowed_target_projects_on_move(User.find(2))
               end
               def test_move_to_another_project_with_same_category
                 issue = Issue.find(1)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Category changes
                 assert_equal 4, issue.category_id
                 # Make sure time entries were move to the target project
                 assert_equal 2, issue.time_entries.first.project_id
               end
               def test_move_to_another_project_without_same_category
                 issue = Issue.find(2)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Category cleared
                 assert_nil issue.category_id
               end
               def test_move_to_another_project_should_clear_fixed_version_when_not_shared
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 1)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Cleared fixed_version
                 assert_equal nil, issue.fixed_version
               end
               def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 4)
                 issue.project = Project.find(5)
                 assert issue.save
                 issue.reload
                 assert_equal 5, issue.project_id
                 # Keep fixed_version
                 assert_equal 4, issue.fixed_version_id
               end
               def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 1)
                 issue.project = Project.find(5)
                 assert issue.save
                 issue.reload
                 assert_equal 5, issue.project_id
                 # Cleared fixed_version
                 assert_equal nil, issue.fixed_version
               end
               def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide
                 issue = Issue.find(1)
                 issue.update_attribute(:fixed_version_id, 7)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 # Keep fixed_version
                 assert_equal 7, issue.fixed_version_id
               end
               def test_move_to_another_project_should_keep_parent_if_valid
                 issue = Issue.find(1)
                 issue.update_attribute(:parent_issue_id, 2)
                 issue.project = Project.find(3)
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.parent_id
               end
               def test_move_to_another_project_should_clear_parent_if_not_valid
                 issue = Issue.find(1)
                 issue.update_attribute(:parent_issue_id, 2)
                 issue.project = Project.find(2)
                 assert issue.save
                 issue.reload
                 assert_nil issue.parent_id
               end
               def test_move_to_another_project_with_disabled_tracker
                 issue = Issue.find(1)
                 target = Project.find(2)
                 target.tracker_ids = [3]
                 target.save
                 issue.project = target
                 assert issue.save
                 issue.reload
                 assert_equal 2, issue.project_id
                 assert_equal 3, issue.tracker_id
               end
               def test_copy_to_the_same_project
                 issue = Issue.find(1)
                 copy = issue.copy
                 assert_difference 'Issue.count' do
                   copy.save!
                 end
                 assert_kind_of Issue, copy
                 assert_equal issue.project, copy.project
                 assert_equal "125", copy.custom_value_for(2).value
               end
               def test_copy_to_another_project_and_tracker
                 issue = Issue.find(1)
                 copy = issue.copy(:project_id => 3, :tracker_id => 2)
                 assert_difference 'Issue.count' do
                   copy.save!
                 end
                 copy.reload
                 assert_kind_of Issue, copy
                 assert_equal Project.find(3), copy.project
                 assert_equal Tracker.find(2), copy.tracker
                 # Custom field #2 is not associated with target tracker
                 assert_nil copy.custom_value_for(2)
               end
               context "#copy" do
                 setup do
                   @issue = Issue.find(1)
                 end
                 should "not create a journal" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
                   copy.save!
                   assert_equal 0, copy.reload.journals.size
                 end
                 should "allow assigned_to changes" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :assigned_to_id => 3)
                   assert_equal 3, copy.assigned_to_id
                 end
                 should "allow status changes" do
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :status_id => 2)
                   assert_equal 2, copy.status_id
                 end
                 should "allow start date changes" do
                   date = Date.today
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
                   assert_equal date, copy.start_date
                 end
                 should "allow due date changes" do
                   date = Date.today
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :due_date => date)
                   assert_equal date, copy.due_date
                 end
                 should "set current user as author" do
                   User.current = User.find(9)
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2)
                   assert_equal User.current, copy.author
                 end
                 should "create a journal with notes" do
                   date = Date.today
                   notes = "Notes added when copying"
                   copy = @issue.copy(:project_id => 3, :tracker_id => 2, :start_date => date)
                   copy.init_journal(User.current, notes)
                   copy.save!
                   assert_equal 1, copy.journals.size
                   journal = copy.journals.first
                   assert_equal 0, journal.details.size
                   assert_equal notes, journal.notes
                 end
               end
               def test_valid_parent_project
                 issue = Issue.find(1)
                 issue_in_same_project = Issue.find(2)
                 issue_in_child_project = Issue.find(5)
                 issue_in_grandchild_project = Issue.generate!(:project_id => 6, :tracker_id => 1)
                 issue_in_other_child_project = Issue.find(6)
                 issue_in_different_tree = Issue.find(4)
                 with_settings :cross_project_subtasks => '' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                 end
                 with_settings :cross_project_subtasks => 'system' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_different_tree)
                 end
                 with_settings :cross_project_subtasks => 'tree' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                 end
                 with_settings :cross_project_subtasks => 'descendants' do
                   assert_equal true, issue.valid_parent_project?(issue_in_same_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_child_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)
                   assert_equal false, issue.valid_parent_project?(issue_in_different_tree)
                   assert_equal true, issue_in_child_project.valid_parent_project?(issue)
                   assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)
                 end
               end
               def test_recipients_should_include_previous_assignee
                 user = User.find(3)
                 user.members.update_all ["mail_notification = ?", false]
                 user.update_attribute :mail_notification, 'only_assigned'
                 issue = Issue.find(2)
                 issue.assigned_to = nil
                 assert_include user.mail, issue.recipients
                 issue.save!
                 assert !issue.recipients.include?(user.mail)
               end
               def test_recipients_should_not_include_users_that_cannot_view_the_issue
                 issue = Issue.find(12)
                 assert issue.recipients.include?(issue.author.mail)
                 # copy the issue to a private project
                 copy  = issue.copy(:project_id => 5, :tracker_id => 2)
                 # author is not a member of project anymore
                 assert !copy.recipients.include?(copy.author.mail)
               end
               def test_recipients_should_include_the_assigned_group_members
                 group_member = User.generate!
                 group = Group.generate!
                 group.users << group_member
                 issue = Issue.find(12)
                 issue.assigned_to = group
                 assert issue.recipients.include?(group_member.mail)
               end
               def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue
                 user = User.find(3)
                 issue = Issue.find(9)
                 Watcher.create!(:user => user, :watchable => issue)
                 assert issue.watched_by?(user)
                 assert !issue.watcher_recipients.include?(user.mail)
               end
               def test_issue_destroy
                 Issue.find(1).destroy
                 assert_nil Issue.find_by_id(1)
                 assert_nil TimeEntry.find_by_issue_id(1)
               end
               def test_destroying_a_deleted_issue_should_not_raise_an_error
                 issue = Issue.find(1)
                 Issue.find(1).destroy
                 assert_nothing_raised do
                   assert_no_difference 'Issue.count' do
                     issue.destroy
                   end
                   assert issue.destroyed?
                 end
               end
               def test_destroying_a_stale_issue_should_not_raise_an_error
                 issue = Issue.find(1)
                 Issue.find(1).update_attribute :subject, "Updated"
                 assert_nothing_raised do
                   assert_difference 'Issue.count', -1 do
                     issue.destroy
                   end
                   assert issue.destroyed?
                 end
               end
               def test_blocked
                 blocked_issue = Issue.find(9)
                 blocking_issue = Issue.find(10)
                 assert blocked_issue.blocked?
                 assert !blocking_issue.blocked?
               end
               def test_blocked_issues_dont_allow_closed_statuses
                 blocked_issue = Issue.find(9)
                 allowed_statuses = blocked_issue.new_statuses_allowed_to(users(:users_002))
                 assert !allowed_statuses.empty?
                 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                 assert closed_statuses.empty?
               end
               def test_unblocked_issues_allow_closed_statuses
                 blocking_issue = Issue.find(10)
                 allowed_statuses = blocking_issue.new_statuses_allowed_to(users(:users_002))
                 assert !allowed_statuses.empty?
                 closed_statuses = allowed_statuses.select {|st| st.is_closed?}
                 assert !closed_statuses.empty?
               end
               def test_rescheduling_an_issue_should_reschedule_following_issue
                 issue1 = Issue.create!(:project_id => 1, :tracker_id => 1,
                                        :author_id => 1, :status_id => 1,
                                        :subject => '-',
                                        :start_date => Date.today, :due_date => Date.today + 2)
                 issue2 = Issue.create!(:project_id => 1, :tracker_id => 1,
                                        :author_id => 1, :status_id => 1,
                                        :subject => '-',
                                        :start_date => Date.today, :due_date => Date.today + 2)
                 IssueRelation.create!(:issue_from => issue1, :issue_to => issue2,
                                       :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal issue1.due_date + 1, issue2.reload.start_date
                 issue1.due_date = Date.today + 5
                 issue1.save!
                 assert_equal issue1.due_date + 1, issue2.reload.start_date
               end
               def test_rescheduling_a_stale_issue_should_not_raise_an_error
                 stale = Issue.find(1)
                 issue = Issue.find(1)
                 issue.subject = "Updated"
                 issue.save!
                 date = 10.days.from_now.to_date
                 assert_nothing_raised do
                   stale.reschedule_after(date)
                 end
                 assert_equal date, stale.reload.start_date
               end
               def test_overdue
                 assert Issue.new(:due_date => 1.day.ago.to_date).overdue?
                 assert !Issue.new(:due_date => Date.today).overdue?
                 assert !Issue.new(:due_date => 1.day.from_now.to_date).overdue?
                 assert !Issue.new(:due_date => nil).overdue?
                 assert !Issue.new(:due_date => 1.day.ago.to_date,
                                   :status => IssueStatus.find(:first,
                                                               :conditions => {:is_closed => true})
                                   ).overdue?
               end
               context "#behind_schedule?" do
                 should "be false if the issue has no start_date" do
                   assert !Issue.new(:start_date => nil,
                                     :due_date => 1.day.from_now.to_date,
                                     :done_ratio => 0).behind_schedule?
                 end
                 should "be false if the issue has no end_date" do
                   assert !Issue.new(:start_date => 1.day.from_now.to_date,
                                     :due_date => nil,
                                     :done_ratio => 0).behind_schedule?
                 end
                 should "be false if the issue has more done than it's calendar time" do
                   assert !Issue.new(:start_date => 50.days.ago.to_date,
                                     :due_date => 50.days.from_now.to_date,
                                     :done_ratio => 90).behind_schedule?
                 end
                 should "be true if the issue hasn't been started at all" do
                   assert Issue.new(:start_date => 1.day.ago.to_date,
                                    :due_date => 1.day.from_now.to_date,
                                    :done_ratio => 0).behind_schedule?
                 end
                 should "be true if the issue has used more calendar time than it's done ratio" do
                   assert Issue.new(:start_date => 100.days.ago.to_date,
                                    :due_date => Date.today,
                                    :done_ratio => 90).behind_schedule?
                 end
               end
               context "#assignable_users" do
                 should "be Users" do
                   assert_kind_of User, Issue.find(1).assignable_users.first
                 end
                 should "include the issue author" do
                   non_project_member = User.generate!
                   issue = Issue.generate!(:author => non_project_member)
                   assert issue.assignable_users.include?(non_project_member)
                 end
                 should "include the current assignee" do
                   user = User.generate!
                   issue = Issue.generate!(:assigned_to => user)
                   user.lock!
                   assert Issue.find(issue.id).assignable_users.include?(user)
                 end
                 should "not show the issue author twice" do
                   assignable_user_ids = Issue.find(1).assignable_users.collect(&:id)
                   assert_equal 2, assignable_user_ids.length
                   assignable_user_ids.each do |user_id|
                     assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length,
                                  "User #{user_id} appears more or less than once"
                   end
                 end
                 context "with issue_group_assignment" do
                   should "include groups" do
                     issue = Issue.new(:project => Project.find(2))
                     with_settings :issue_group_assignment => '1' do
                       assert_equal %w(Group User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                       assert issue.assignable_users.include?(Group.find(11))
                     end
                   end
                 end
                 context "without issue_group_assignment" do
                   should "not include groups" do
                     issue = Issue.new(:project => Project.find(2))
                     with_settings :issue_group_assignment => '0' do
                       assert_equal %w(User), issue.assignable_users.map {|a| a.class.name}.uniq.sort
                       assert !issue.assignable_users.include?(Group.find(11))
                     end
                   end
                 end
               end
               def test_create_should_send_email_notification
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.new(:project_id => 1, :tracker_id => 1,
                                   :author_id => 3, :status_id => 1,
                                   :priority => IssuePriority.all.first,
                                   :subject => 'test_create', :estimated_hours => '1:30')
                 assert issue.save
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_stale_issue_should_not_send_email_notification
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 stale = Issue.find(1)
                 issue.init_journal(User.find(1))
                 issue.subject = 'Subjet update'
                 assert issue.save
                 assert_equal 1, ActionMailer::Base.deliveries.size
                 ActionMailer::Base.deliveries.clear
                 stale.init_journal(User.find(1))
                 stale.subject = 'Another subjet update'
                 assert_raise ActiveRecord::StaleObjectError do
                   stale.save
                 end
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_journalized_description
                 IssueCustomField.delete_all
                 i = Issue.first
                 old_description = i.description
                 new_description = "This is the new description"
                 i.init_journal(User.find(2))
                 i.description = new_description
                 assert_difference 'Journal.count', 1 do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save!
                   end
                 end
                 detail = JournalDetail.first(:order => 'id DESC')
                 assert_equal i, detail.journal.journalized
                 assert_equal 'attr', detail.property
                 assert_equal 'description', detail.prop_key
                 assert_equal old_description, detail.old_value
                 assert_equal new_description, detail.value
               end
               def test_blank_descriptions_should_not_be_journalized
                 IssueCustomField.delete_all
                 Issue.update_all("description = NULL", "id=1")
                 i = Issue.find(1)
                 i.init_journal(User.find(2))
                 i.subject = "blank description"
                 i.description = "\r\n"
                 assert_difference 'Journal.count', 1 do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save!
                   end
                 end
               end
               def test_journalized_multi_custom_field
                 field = IssueCustomField.create!(:name => 'filter', :field_format => 'list',
                                                  :is_filter => true, :is_for_all => true,
                                                  :tracker_ids => [1],
                                                  :possible_values => ['value1', 'value2', 'value3'],
                                                  :multiple => true)
                 issue = Issue.create!(:project_id => 1, :tracker_id => 1,
                                       :subject => 'Test', :author_id => 1)
                 assert_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count' do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value1']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count' do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value1', 'value2']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count', 2 do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => ['value3', 'value2']}
                     issue.save!
                   end
                   assert_difference 'JournalDetail.count', 2 do
                     issue.init_journal(User.first)
                     issue.custom_field_values = {field.id => nil}
                     issue.save!
                   end
                 end
               end
               def test_description_eol_should_be_normalized
                 i = Issue.new(:description => "CR \r LF \n CRLF \r\n")
                 assert_equal "CR \r\n LF \r\n CRLF \r\n", i.description
               end
               def test_saving_twice_should_not_duplicate_journal_details
                 i = Issue.find(:first)
                 i.init_journal(User.find(2), 'Some notes')
                 # initial changes
                 i.subject = 'New subject'
                 i.done_ratio = i.done_ratio + 10
                 assert_difference 'Journal.count' do
                   assert i.save
                 end
                 # 1 more change
                 i.priority = IssuePriority.find(:first, :conditions => ["id <> ?", i.priority_id])
                 assert_no_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count', 1 do
                     i.save
                   end
                 end
                 # no more change
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'JournalDetail.count' do
                     i.save
                   end
                 end
               end
               def test_all_dependent_issues
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(3),
                                              :issue_to   => Issue.find(8),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               def test_all_dependent_issues_with_persistent_circular_dependency
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_PRECEDES)
                 r = IssueRelation.create!(:issue_from => Issue.find(3),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_PRECEDES)
                 IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                 assert_equal [2, 3], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               def test_all_dependent_issues_with_persistent_multiple_circular_dependencies
                 IssueRelation.delete_all
                 assert IssueRelation.create!(:issue_from => Issue.find(1),
                                              :issue_to   => Issue.find(2),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 assert IssueRelation.create!(:issue_from => Issue.find(2),
                                              :issue_to   => Issue.find(3),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 assert IssueRelation.create!(:issue_from => Issue.find(3),
                                              :issue_to   => Issue.find(8),
                                              :relation_type => IssueRelation::TYPE_RELATES)
                 r = IssueRelation.create!(:issue_from => Issue.find(8),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_RELATES)
                 IssueRelation.update_all("issue_to_id = 2", ["id = ?", r.id])
                 r = IssueRelation.create!(:issue_from => Issue.find(3),
                                          :issue_to   => Issue.find(7),
                                          :relation_type => IssueRelation::TYPE_RELATES)
                 IssueRelation.update_all("issue_to_id = 1", ["id = ?", r.id])
                 assert_equal [2, 3, 8], Issue.find(1).all_dependent_issues.collect(&:id).sort
               end
               context "#done_ratio" do
                 setup do
                   @issue = Issue.find(1)
                   @issue_status = IssueStatus.find(1)
                   @issue_status.update_attribute(:default_done_ratio, 50)
                   @issue2 = Issue.find(2)
                   @issue_status2 = IssueStatus.find(2)
                   @issue_status2.update_attribute(:default_done_ratio, 0)
                 end
                 teardown do
                   Setting.issue_done_ratio = 'issue_field'
                 end
                 context "with Setting.issue_done_ratio using the issue_field" do
                   setup do
                     Setting.issue_done_ratio = 'issue_field'
                   end
                   should "read the issue's field" do
                     assert_equal 0, @issue.done_ratio
                     assert_equal 30, @issue2.done_ratio
                   end
                 end
                 context "with Setting.issue_done_ratio using the issue_status" do
                   setup do
                     Setting.issue_done_ratio = 'issue_status'
                   end
                   should "read the Issue Status's default done ratio" do
                     assert_equal 50, @issue.done_ratio
                     assert_equal 0, @issue2.done_ratio
                   end
                 end
               end
               context "#update_done_ratio_from_issue_status" do
                 setup do
                   @issue = Issue.find(1)
                   @issue_status = IssueStatus.find(1)
                   @issue_status.update_attribute(:default_done_ratio, 50)
                   @issue2 = Issue.find(2)
                   @issue_status2 = IssueStatus.find(2)
                   @issue_status2.update_attribute(:default_done_ratio, 0)
                 end
                 context "with Setting.issue_done_ratio using the issue_field" do
                   setup do
                     Setting.issue_done_ratio = 'issue_field'
                   end
                   should "not change the issue" do
                     @issue.update_done_ratio_from_issue_status
                     @issue2.update_done_ratio_from_issue_status
                     assert_equal 0, @issue.read_attribute(:done_ratio)
                     assert_equal 30, @issue2.read_attribute(:done_ratio)
                   end
                 end
                 context "with Setting.issue_done_ratio using the issue_status" do
                   setup do
                     Setting.issue_done_ratio = 'issue_status'
                   end
                   should "change the issue's done ratio" do
                     @issue.update_done_ratio_from_issue_status
                     @issue2.update_done_ratio_from_issue_status
                     assert_equal 50, @issue.read_attribute(:done_ratio)
                     assert_equal 0, @issue2.read_attribute(:done_ratio)
                   end
                 end
               end
               test "#by_tracker" do
                 User.current = User.anonymous
                 groups = Issue.by_tracker(Project.find(1))
                 assert_equal 3, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_version" do
                 User.current = User.anonymous
                 groups = Issue.by_version(Project.find(1))
                 assert_equal 3, groups.size
                 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_priority" do
                 User.current = User.anonymous
                 groups = Issue.by_priority(Project.find(1))
                 assert_equal 4, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_category" do
                 User.current = User.anonymous
                 groups = Issue.by_category(Project.find(1))
                 assert_equal 2, groups.size
                 assert_equal 3, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_assigned_to" do
                 User.current = User.anonymous
                 groups = Issue.by_assigned_to(Project.find(1))
                 assert_equal 2, groups.size
                 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_author" do
                 User.current = User.anonymous
                 groups = Issue.by_author(Project.find(1))
                 assert_equal 4, groups.size
                 assert_equal 7, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               test "#by_subproject" do
                 User.current = User.anonymous
                 groups = Issue.by_subproject(Project.find(1))
                 # Private descendant not visible
                 assert_equal 1, groups.size
                 assert_equal 2, groups.inject(0) {|sum, group| sum + group['total'].to_i}
               end
               def test_recently_updated_scope
                 #should return the last updated issue
                 assert_equal Issue.reorder("updated_on DESC").first, Issue.recently_updated.limit(1).first
               end
               def test_on_active_projects_scope
                 assert Project.find(2).archive
                 before = Issue.on_active_project.length
                 # test inclusion to results
                 issue = Issue.generate!(:tracker => Project.find(2).trackers.first)
                 assert_equal before + 1, Issue.on_active_project.length
                 # Move to an archived project
                 issue.project = Project.find(2)
                 assert issue.save
                 assert_equal before, Issue.on_active_project.length
               end
               context "Issue#recipients" do
                 setup do
                   @project = Project.find(1)
                   @author = User.generate!
                   @assignee = User.generate!
                   @issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)
                 end
                 should "include project recipients" do
                   assert @project.recipients.present?
                   @project.recipients.each do |project_recipient|
                     assert @issue.recipients.include?(project_recipient)
                   end
                 end
                 should "include the author if the author is active" do
                   assert @issue.author, "No author set for Issue"
                   assert @issue.recipients.include?(@issue.author.mail)
                 end
                 should "include the assigned to user if the assigned to user is active" do
                   assert @issue.assigned_to, "No assigned_to set for Issue"
                   assert @issue.recipients.include?(@issue.assigned_to.mail)
                 end
                 should "not include users who opt out of all email" do
                   @author.update_attribute(:mail_notification, :none)
                   assert !@issue.recipients.include?(@issue.author.mail)
                 end
                 should "not include the issue author if they are only notified of assigned issues" do
                   @author.update_attribute(:mail_notification, :only_assigned)
                   assert !@issue.recipients.include?(@issue.author.mail)
                 end
                 should "not include the assigned user if they are only notified of owned issues" do
                   @assignee.update_attribute(:mail_notification, :only_owner)
                   assert !@issue.recipients.include?(@issue.assigned_to.mail)
                 end
               end
               def test_last_journal_id_with_journals_should_return_the_journal_id
                 assert_equal 2, Issue.find(1).last_journal_id
               end
               def test_last_journal_id_without_journals_should_return_nil
                 assert_nil Issue.find(3).last_journal_id
               end
               def test_journals_after_should_return_journals_with_greater_id
                 assert_equal [Journal.find(2)], Issue.find(1).journals_after('1')
                 assert_equal [], Issue.find(1).journals_after('2')
               end
               def test_journals_after_with_blank_arg_should_return_all_journals
                 assert_equal [Journal.find(1), Journal.find(2)], Issue.find(1).journals_after('')
               end
             end