jro_apps/redmine Commit - r10440:d5abb11c0ba2

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,

675

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

676

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

676

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

677

:rule => 'required')

677

:rule => 'required')

678

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

678

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

679

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

679

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

680

:rule => 'required')

680

:rule => 'required')

681

user = User.find(2)

681

user = User.find(2)

682

member = Member.find(1)

682

member = Member.find(1)

683

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)

684

685

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

686

687

member.role_ids = [1, 2]

687

member.role_ids = [1, 2]

688

member.save!

688

member.save!

689

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

689

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

690

691

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

691

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

692

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

692

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

693

:rule => 'required')

693

:rule => 'required')

694

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

694

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

695

696

member.role_ids = [1, 2, 3]

696

member.role_ids = [1, 2, 3]

697

member.save!

697

member.save!

698

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

698

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

699

700

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

700

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

701

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

701

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

702

:rule => 'readonly')

702

:rule => 'readonly')

703

# required + readonly => required

703

# required + readonly => required

704

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

704

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

705

end

705

end

706

707

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

708

WorkflowPermission.delete_all

708

WorkflowPermission.delete_all

709

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

709

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

710

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

710

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

711

:rule => 'readonly')

711

:rule => 'readonly')

712

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

712

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

713

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

713

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

714

:rule => 'readonly')

714

:rule => 'readonly')

715

user = User.find(2)

715

user = User.find(2)

716

member = Member.find(1)

716

member = Member.find(1)

717

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

717

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

718

719

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

719

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

720

721

member.role_ids = [1, 2]

721

member.role_ids = [1, 2]

722

member.save!

722

member.save!

723

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

723

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

724

725

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

725

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

726

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

726

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

727

:rule => 'readonly')

727

:rule => 'readonly')

728

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

728

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

729

end

729

end

730

731

def test_copy

731

def test_copy

732

issue = Issue.new.copy_from(1)

732

issue = Issue.new.copy_from(1)

733

assert issue.copy?

733

assert issue.copy?

734

assert issue.save

734

assert issue.save

735

issue.reload

735

issue.reload

736

orig = Issue.find(1)

736

orig = Issue.find(1)

737

assert_equal orig.subject, issue.subject

737

assert_equal orig.subject, issue.subject

738

assert_equal orig.tracker, issue.tracker

738

assert_equal orig.tracker, issue.tracker

739

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

739

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

740

end

740

end

741

742

def test_copy_should_copy_status

742

def test_copy_should_copy_status

743

orig = Issue.find(8)

743

orig = Issue.find(8)

744

assert orig.status != IssueStatus.default

744

assert orig.status != IssueStatus.default

745

746

issue = Issue.new.copy_from(orig)

746

issue = Issue.new.copy_from(orig)

747

assert issue.save

747

assert issue.save

748

issue.reload

748

issue.reload

749

assert_equal orig.status, issue.status

749

assert_equal orig.status, issue.status

750

end

750

end

751

752

def test_copy_should_add_relation_with_copied_issue

752

def test_copy_should_add_relation_with_copied_issue

753

copied = Issue.find(1)

753

copied = Issue.find(1)

754

issue = Issue.new.copy_from(copied)

754

issue = Issue.new.copy_from(copied)

755

assert issue.save

755

assert issue.save

756

issue.reload

756

issue.reload

757

758

assert_equal 1, issue.relations.size

758

assert_equal 1, issue.relations.size

759

relation = issue.relations.first

759

relation = issue.relations.first

760

assert_equal 'copied_to', relation.relation_type

760

assert_equal 'copied_to', relation.relation_type

761

assert_equal copied, relation.issue_from

761

assert_equal copied, relation.issue_from

762

assert_equal issue, relation.issue_to

762

assert_equal issue, relation.issue_to

763

end

763

end

764

765

def test_copy_should_copy_subtasks

765

def test_copy_should_copy_subtasks

766

issue = Issue.generate_with_descendants!

766

issue = Issue.generate_with_descendants!

767

768

copy = issue.reload.copy

768

copy = issue.reload.copy

769

copy.author = User.find(7)

769

copy.author = User.find(7)

770

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

770

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

771

assert copy.save

771

assert copy.save

772

end

772

end

773

copy.reload

773

copy.reload

774

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

774

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

775

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

775

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

776

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

776

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

777

assert_equal copy.author, child_copy.author

777

assert_equal copy.author, child_copy.author

778

end

778

end

779

780

def test_copy_should_copy_subtasks_to_target_project

780

def test_copy_should_copy_subtasks_to_target_project

781

issue = Issue.generate_with_descendants!

781

issue = Issue.generate_with_descendants!

782

783

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

783

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

784

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

784

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

785

assert copy.save

785

assert copy.save

786

end

786

end

787

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

787

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

788

end

788

end

789

790

def test_copy_should_not_copy_subtasks_twice_when_saving_twice

790

def test_copy_should_not_copy_subtasks_twice_when_saving_twice

791

issue = Issue.generate_with_descendants!

791

issue = Issue.generate_with_descendants!

792

793

copy = issue.reload.copy

793

copy = issue.reload.copy

794

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

794

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

795

assert copy.save

795

assert copy.save

796

assert copy.save

796

assert copy.save

797

end

797

end

798

end

798

end

799

800

def test_should_not_call_after_project_change_on_creation

800

def test_should_not_call_after_project_change_on_creation

801

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

801

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

802

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

802

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

803

issue.expects(:after_project_change).never

803

issue.expects(:after_project_change).never

804

issue.save!

804

issue.save!

805

end

805

end

806

807

def test_should_not_call_after_project_change_on_update

807

def test_should_not_call_after_project_change_on_update

808

issue = Issue.find(1)

808

issue = Issue.find(1)

809

issue.project = Project.find(1)

809

issue.project = Project.find(1)

810

issue.subject = 'No project change'

810

issue.subject = 'No project change'

811

issue.expects(:after_project_change).never

811

issue.expects(:after_project_change).never

812

issue.save!

812

issue.save!

813

end

813

end

814

815

def test_should_call_after_project_change_on_project_change

815

def test_should_call_after_project_change_on_project_change

816

issue = Issue.find(1)

816

issue = Issue.find(1)

817

issue.project = Project.find(2)

817

issue.project = Project.find(2)

818

issue.expects(:after_project_change).once

818

issue.expects(:after_project_change).once

819

issue.save!

819

issue.save!

820

end

820

end

821

822

def test_adding_journal_should_update_timestamp

822

def test_adding_journal_should_update_timestamp

823

issue = Issue.find(1)

823

issue = Issue.find(1)

824

updated_on_was = issue.updated_on

824

updated_on_was = issue.updated_on

825

826

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

826

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

827

assert_difference 'Journal.count' do

827

assert_difference 'Journal.count' do

828

assert issue.save

828

assert issue.save

829

end

829

end

830

issue.reload

830

issue.reload

831

832

assert_not_equal updated_on_was, issue.updated_on

832

assert_not_equal updated_on_was, issue.updated_on

833

end

833

end

834

835

def test_should_close_duplicates

835

def test_should_close_duplicates

836

# Create 3 issues

836

# Create 3 issues

837

issue1 = Issue.generate!

837

issue1 = Issue.generate!

838

issue2 = Issue.generate!

838

issue2 = Issue.generate!

839

issue3 = Issue.generate!

839

issue3 = Issue.generate!

840

841

# 2 is a dupe of 1

841

# 2 is a dupe of 1

842

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

842

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

843

:relation_type => IssueRelation::TYPE_DUPLICATES)

843

# And 3 is a dupe of 2

844

# And 3 is a dupe of 2

844

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

845

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

846

:relation_type => IssueRelation::TYPE_DUPLICATES)

845

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

847

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

846

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

848

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

849

:relation_type => IssueRelation::TYPE_DUPLICATES)

847

850

848

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

851

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

849

852

850

# Closing issue 1

853

# Closing issue 1

851

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

854

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

852

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

855

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

853

assert issue1.save

856

assert issue1.save

854

# 2 and 3 should be also closed

857

# 2 and 3 should be also closed

855

assert issue2.reload.closed?

858

assert issue2.reload.closed?

856

assert issue3.reload.closed?

859

assert issue3.reload.closed?

857

end

860

end

858

861

859

def test_should_not_close_duplicated_issue

862

def test_should_not_close_duplicated_issue

860

issue1 = Issue.generate!

863

issue1 = Issue.generate!

861

issue2 = Issue.generate!

864

issue2 = Issue.generate!

862

865

863

# 2 is a dupe of 1

866

# 2 is a dupe of 1

864

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

867

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

865

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

868

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

866

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

869

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

867

870

868

# Closing issue 2

871

# Closing issue 2

869

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

872

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

870

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

873

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

871

assert issue2.save

874

assert issue2.save

872

# 1 should not be also closed

875

# 1 should not be also closed

873

assert !issue1.reload.closed?

876

assert !issue1.reload.closed?

874

end

877

end

875

878

876

def test_assignable_versions

879

def test_assignable_versions

877

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

880

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

878

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

881

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

879

end

882

end

880

883

881

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

884

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

882

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

885

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

883

assert !issue.save

886

assert !issue.save

884

assert_not_nil issue.errors[:fixed_version_id]

887

assert_not_nil issue.errors[:fixed_version_id]

885

end

888

end

886

889

887

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

890

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

888

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

891

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

889

assert !issue.save

892

assert !issue.save

890

assert_not_nil issue.errors[:fixed_version_id]

893

assert_not_nil issue.errors[:fixed_version_id]

891

end

894

end

892

895

893

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

896

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

894

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

897

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

895

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

898

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

896

:subject => 'New issue')

899

:subject => 'New issue')

897

assert issue.save

900

assert issue.save

898

end

901

end

899

902

900

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

903

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

901

issue = Issue.find(11)

904

issue = Issue.find(11)

902

assert_equal 'closed', issue.fixed_version.status

905

assert_equal 'closed', issue.fixed_version.status

903

issue.subject = 'Subject changed'

906

issue.subject = 'Subject changed'

904

assert issue.save

907

assert issue.save

905

end

908

end

906

909

907

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

910

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

908

issue = Issue.find(11)

911

issue = Issue.find(11)

909

issue.status_id = 1

912

issue.status_id = 1

910

assert !issue.save

913

assert !issue.save

911

assert_not_nil issue.errors[:base]

914

assert_not_nil issue.errors[:base]

912

end

915

end

913

916

914

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

917

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

915

issue = Issue.find(11)

918

issue = Issue.find(11)

916

issue.status_id = 1

919

issue.status_id = 1

917

issue.fixed_version_id = 3

920

issue.fixed_version_id = 3

918

assert issue.save

921

assert issue.save

919

end

922

end

920

923

921

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

924

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

922

issue = Issue.find(12)

925

issue = Issue.find(12)

923

assert_equal 'locked', issue.fixed_version.status

926

assert_equal 'locked', issue.fixed_version.status

924

issue.status_id = 1

927

issue.status_id = 1

925

assert issue.save

928

assert issue.save

926

end

929

end

927

930

928

def test_should_not_be_able_to_keep_unshared_version_when_changing_project

931

def test_should_not_be_able_to_keep_unshared_version_when_changing_project

929

issue = Issue.find(2)

932

issue = Issue.find(2)

930

assert_equal 2, issue.fixed_version_id

933

assert_equal 2, issue.fixed_version_id

931

issue.project_id = 3

934

issue.project_id = 3

932

assert_nil issue.fixed_version_id

935

assert_nil issue.fixed_version_id

933

issue.fixed_version_id = 2

936

issue.fixed_version_id = 2

934

assert !issue.save

937

assert !issue.save

935

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

938

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

936

end

939

end

937

940

938

def test_should_keep_shared_version_when_changing_project

941

def test_should_keep_shared_version_when_changing_project

939

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

942

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

940

943

941

issue = Issue.find(2)

944

issue = Issue.find(2)

942

assert_equal 2, issue.fixed_version_id

945

assert_equal 2, issue.fixed_version_id

943

issue.project_id = 3

946

issue.project_id = 3

944

assert_equal 2, issue.fixed_version_id

947

assert_equal 2, issue.fixed_version_id

945

assert issue.save

948

assert issue.save

946

end

949

end

947

950

948

def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled

951

def test_allowed_target_projects_on_move_should_include_projects_with_issue_tracking_enabled

949

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

952

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

950

end

953

end

951

954

952

def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled

955

def test_allowed_target_projects_on_move_should_not_include_projects_with_issue_tracking_disabled

953

Project.find(2).disable_module! :issue_tracking

956

Project.find(2).disable_module! :issue_tracking

954

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

957

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

955

end

958

end

956

959

957

def test_move_to_another_project_with_same_category

960

def test_move_to_another_project_with_same_category

958

issue = Issue.find(1)

961

issue = Issue.find(1)

959

issue.project = Project.find(2)

962

issue.project = Project.find(2)

960

assert issue.save

963

assert issue.save

961

issue.reload

964

issue.reload

962

assert_equal 2, issue.project_id

965

assert_equal 2, issue.project_id

963

# Category changes

966

# Category changes

964

assert_equal 4, issue.category_id

967

assert_equal 4, issue.category_id

965

# Make sure time entries were move to the target project

968

# Make sure time entries were move to the target project

966

assert_equal 2, issue.time_entries.first.project_id

969

assert_equal 2, issue.time_entries.first.project_id

967

end

970

end

968

971

969

def test_move_to_another_project_without_same_category

972

def test_move_to_another_project_without_same_category

970

issue = Issue.find(2)

973

issue = Issue.find(2)

971

issue.project = Project.find(2)

974

issue.project = Project.find(2)

972

assert issue.save

975

assert issue.save

973

issue.reload

976

issue.reload

974

assert_equal 2, issue.project_id

977

assert_equal 2, issue.project_id

975

# Category cleared

978

# Category cleared

976

assert_nil issue.category_id

979

assert_nil issue.category_id

977

end

980

end

978

981

979

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

982

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

980

issue = Issue.find(1)

983

issue = Issue.find(1)

981

issue.update_attribute(:fixed_version_id, 1)

984

issue.update_attribute(:fixed_version_id, 1)

982

issue.project = Project.find(2)

985

issue.project = Project.find(2)

983

assert issue.save

986

assert issue.save

984

issue.reload

987

issue.reload

985

assert_equal 2, issue.project_id

988

assert_equal 2, issue.project_id

986

# Cleared fixed_version

989

# Cleared fixed_version

987

assert_equal nil, issue.fixed_version

990

assert_equal nil, issue.fixed_version

988

end

991

end

989

992

990

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

993

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

991

issue = Issue.find(1)

994

issue = Issue.find(1)

992

issue.update_attribute(:fixed_version_id, 4)

995

issue.update_attribute(:fixed_version_id, 4)

993

issue.project = Project.find(5)

996

issue.project = Project.find(5)

994

assert issue.save

997

assert issue.save

995

issue.reload

998

issue.reload

996

assert_equal 5, issue.project_id

999

assert_equal 5, issue.project_id

997

# Keep fixed_version

1000

# Keep fixed_version

998

assert_equal 4, issue.fixed_version_id

1001

assert_equal 4, issue.fixed_version_id

999

end

1002

end

1000

1003

1001

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

1004

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

1002

issue = Issue.find(1)

1005

issue = Issue.find(1)

1003

issue.update_attribute(:fixed_version_id, 1)

1006

issue.update_attribute(:fixed_version_id, 1)

1004

issue.project = Project.find(5)

1007

issue.project = Project.find(5)

1005

assert issue.save

1008

assert issue.save

1006

issue.reload

1009

issue.reload

1007

assert_equal 5, issue.project_id

1010

assert_equal 5, issue.project_id

1008

# Cleared fixed_version

1011

# Cleared fixed_version

1009

assert_equal nil, issue.fixed_version

1012

assert_equal nil, issue.fixed_version

1010

end

1013

end

1011

1014

1012

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

1015

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

1013

issue = Issue.find(1)

1016

issue = Issue.find(1)

1014

issue.update_attribute(:fixed_version_id, 7)

1017

issue.update_attribute(:fixed_version_id, 7)

1015

issue.project = Project.find(2)

1018

issue.project = Project.find(2)

1016

assert issue.save

1019

assert issue.save

1017

issue.reload

1020

issue.reload

1018

assert_equal 2, issue.project_id

1021

assert_equal 2, issue.project_id

1019

# Keep fixed_version

1022

# Keep fixed_version

1020

assert_equal 7, issue.fixed_version_id

1023

assert_equal 7, issue.fixed_version_id

1021

end

1024

end

1022

1025

1023

def test_move_to_another_project_should_keep_parent_if_valid

1026

def test_move_to_another_project_should_keep_parent_if_valid

1024

issue = Issue.find(1)

1027

issue = Issue.find(1)

1025

issue.update_attribute(:parent_issue_id, 2)

1028

issue.update_attribute(:parent_issue_id, 2)

1026

issue.project = Project.find(3)

1029

issue.project = Project.find(3)

1027

assert issue.save

1030

assert issue.save

1028

issue.reload

1031

issue.reload

1029

assert_equal 2, issue.parent_id

1032

assert_equal 2, issue.parent_id

1030

end

1033

end

1031

1034

1032

def test_move_to_another_project_should_clear_parent_if_not_valid

1035

def test_move_to_another_project_should_clear_parent_if_not_valid

1033

issue = Issue.find(1)

1036

issue = Issue.find(1)

1034

issue.update_attribute(:parent_issue_id, 2)

1037

issue.update_attribute(:parent_issue_id, 2)

1035

issue.project = Project.find(2)

1038

issue.project = Project.find(2)

1036

assert issue.save

1039

assert issue.save

1037

issue.reload

1040

issue.reload

1038

assert_nil issue.parent_id

1041

assert_nil issue.parent_id

1039

end

1042

end

1040

1043

1041

def test_move_to_another_project_with_disabled_tracker

1044

def test_move_to_another_project_with_disabled_tracker

1042

issue = Issue.find(1)

1045

issue = Issue.find(1)

1043

target = Project.find(2)

1046

target = Project.find(2)

1044

target.tracker_ids = [3]

1047

target.tracker_ids = [3]

1045

target.save

1048

target.save

1046

issue.project = target

1049

issue.project = target

1047

assert issue.save

1050

assert issue.save

1048

issue.reload

1051

issue.reload

1049

assert_equal 2, issue.project_id

1052

assert_equal 2, issue.project_id

1050

assert_equal 3, issue.tracker_id

1053

assert_equal 3, issue.tracker_id

1051

end

1054

end

1052

1055

1053

def test_copy_to_the_same_project

1056

def test_copy_to_the_same_project

1054

issue = Issue.find(1)

1057

issue = Issue.find(1)

1055

copy = issue.copy

1058

copy = issue.copy

1056

assert_difference 'Issue.count' do

1059

assert_difference 'Issue.count' do

1057

copy.save!

1060

copy.save!

1058

end

1061

end

1059

assert_kind_of Issue, copy

1062

assert_kind_of Issue, copy

1060

assert_equal issue.project, copy.project

1063

assert_equal issue.project, copy.project

1061

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

1064

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

1062

end

1065

end

1063

1066

1064

def test_copy_to_another_project_and_tracker

1067

def test_copy_to_another_project_and_tracker

1065

issue = Issue.find(1)

1068

issue = Issue.find(1)

1066

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

1069

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

1067

assert_difference 'Issue.count' do

1070

assert_difference 'Issue.count' do

1068

copy.save!

1071

copy.save!

1069

end

1072

end

1070

copy.reload

1073

copy.reload

1071

assert_kind_of Issue, copy

1074

assert_kind_of Issue, copy

1072

assert_equal Project.find(3), copy.project

1075

assert_equal Project.find(3), copy.project

1073

assert_equal Tracker.find(2), copy.tracker

1076

assert_equal Tracker.find(2), copy.tracker

1074

# Custom field #2 is not associated with target tracker

1077

# Custom field #2 is not associated with target tracker

1075

assert_nil copy.custom_value_for(2)

1078

assert_nil copy.custom_value_for(2)

1076

end

1079

end

1077

1080

1078

context "#copy" do

1081

context "#copy" do

1079

setup do

1082

setup do

1080

@issue = Issue.find(1)

1083

@issue = Issue.find(1)

1081

end

1084

end

1082

1085

1083

should "not create a journal" do

1086

should "not create a journal" do

1084

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

1087

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

1085

copy.save!

1088

copy.save!

1086

assert_equal 0, copy.reload.journals.size

1089

assert_equal 0, copy.reload.journals.size

1087

end

1090

end

1088

1091

1089

should "allow assigned_to changes" do

1092

should "allow assigned_to changes" do

1090

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

1093

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

1091

assert_equal 3, copy.assigned_to_id

1094

assert_equal 3, copy.assigned_to_id

1092

end

1095

end

1093

1096

1094

should "allow status changes" do

1097

should "allow status changes" do

1095

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

1098

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

1096

assert_equal 2, copy.status_id

1099

assert_equal 2, copy.status_id

1097

end

1100

end

1098

1101

1099

should "allow start date changes" do

1102

should "allow start date changes" do

1100

date = Date.today

1103

date = Date.today

1101

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

1104

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

1102

assert_equal date, copy.start_date

1105

assert_equal date, copy.start_date

1103

end

1106

end

1104

1107

1105

should "allow due date changes" do

1108

should "allow due date changes" do

1106

date = Date.today

1109

date = Date.today

1107

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

1110

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

1108

assert_equal date, copy.due_date

1111

assert_equal date, copy.due_date

1109

end

1112

end

1110

1113

1111

should "set current user as author" do

1114

should "set current user as author" do

1112

User.current = User.find(9)

1115

User.current = User.find(9)

1113

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

1116

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

1114

assert_equal User.current, copy.author

1117

assert_equal User.current, copy.author

1115

end

1118

end

1116

1119

1117

should "create a journal with notes" do

1120

should "create a journal with notes" do

1118

date = Date.today

1121

date = Date.today

1119

notes = "Notes added when copying"

1122

notes = "Notes added when copying"

1120

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

1123

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

1121

copy.init_journal(User.current, notes)

1124

copy.init_journal(User.current, notes)

1122

copy.save!

1125

copy.save!

1123

1126

1124

assert_equal 1, copy.journals.size

1127

assert_equal 1, copy.journals.size

1125

journal = copy.journals.first

1128

journal = copy.journals.first

1126

assert_equal 0, journal.details.size

1129

assert_equal 0, journal.details.size

1127

assert_equal notes, journal.notes

1130

assert_equal notes, journal.notes

1128

end

1131

end

1129

end

1132

end

1130

1133

1131

def test_valid_parent_project

1134

def test_valid_parent_project

1132

issue = Issue.find(1)

1135

issue = Issue.find(1)

1133

issue_in_same_project = Issue.find(2)

1136

issue_in_same_project = Issue.find(2)

1134

issue_in_child_project = Issue.find(5)

1137

issue_in_child_project = Issue.find(5)

1135

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

1138

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

1136

issue_in_other_child_project = Issue.find(6)

1139

issue_in_other_child_project = Issue.find(6)

1137

issue_in_different_tree = Issue.find(4)

1140

issue_in_different_tree = Issue.find(4)

1138

1141

1139

with_settings :cross_project_subtasks => '' do

1142

with_settings :cross_project_subtasks => '' do

1140

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1143

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1141

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1144

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1142

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1145

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1143

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1146

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1144

end

1147

end

1145

1148

1146

with_settings :cross_project_subtasks => 'system' do

1149

with_settings :cross_project_subtasks => 'system' do

1147

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1150

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1148

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1151

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1149

assert_equal true, issue.valid_parent_project?(issue_in_different_tree)

1152

assert_equal true, issue.valid_parent_project?(issue_in_different_tree)

1150

end

1153

end

1151

1154

1152

with_settings :cross_project_subtasks => 'tree' do

1155

with_settings :cross_project_subtasks => 'tree' do

1153

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1156

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1154

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1157

assert_equal true, issue.valid_parent_project?(issue_in_child_project)

1155

assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)

1158

assert_equal true, issue.valid_parent_project?(issue_in_grandchild_project)

1156

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1159

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1157

1160

1158

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)

1161

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_same_project)

1159

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1162

assert_equal true, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1160

end

1163

end

1161

1164

1162

with_settings :cross_project_subtasks => 'descendants' do

1165

with_settings :cross_project_subtasks => 'descendants' do

1163

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1166

assert_equal true, issue.valid_parent_project?(issue_in_same_project)

1164

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1167

assert_equal false, issue.valid_parent_project?(issue_in_child_project)

1165

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1168

assert_equal false, issue.valid_parent_project?(issue_in_grandchild_project)

1166

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1169

assert_equal false, issue.valid_parent_project?(issue_in_different_tree)

1167

1170

1168

assert_equal true, issue_in_child_project.valid_parent_project?(issue)

1171

assert_equal true, issue_in_child_project.valid_parent_project?(issue)

1169

assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1172

assert_equal false, issue_in_child_project.valid_parent_project?(issue_in_other_child_project)

1170

end

1173

end

1171

end

1174

end

1172

1175

1173

def test_recipients_should_include_previous_assignee

1176

def test_recipients_should_include_previous_assignee

1174

user = User.find(3)

1177

user = User.find(3)

1175

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

1178

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

1176

user.update_attribute :mail_notification, 'only_assigned'

1179

user.update_attribute :mail_notification, 'only_assigned'

1177

1180

1178

issue = Issue.find(2)

1181

issue = Issue.find(2)

1179

issue.assigned_to = nil

1182

issue.assigned_to = nil

1180

assert_include user.mail, issue.recipients

1183

assert_include user.mail, issue.recipients

1181

issue.save!

1184

issue.save!

1182

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

1185

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

1183

end

1186

end

1184

1187

1185

def test_recipients_should_not_include_users_that_cannot_view_the_issue

1188

def test_recipients_should_not_include_users_that_cannot_view_the_issue

1186

issue = Issue.find(12)

1189

issue = Issue.find(12)

1187

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

1190

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

1188

# copy the issue to a private project

1191

# copy the issue to a private project

1189

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

1192

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

1190

# author is not a member of project anymore

1193

# author is not a member of project anymore

1191

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

1194

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

1192

end

1195

end

1193

1196

1194

def test_recipients_should_include_the_assigned_group_members

1197

def test_recipients_should_include_the_assigned_group_members

1195

group_member = User.generate!

1198

group_member = User.generate!

1196

group = Group.generate!

1199

group = Group.generate!

1197

group.users << group_member

1200

group.users << group_member

1198

1201

1199

issue = Issue.find(12)

1202

issue = Issue.find(12)

1200

issue.assigned_to = group

1203

issue.assigned_to = group

1201

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

1204

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

1202

end

1205

end

1203

1206

1204

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

1207

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

1205

user = User.find(3)

1208

user = User.find(3)

1206

issue = Issue.find(9)

1209

issue = Issue.find(9)

1207

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

1210

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

1208

assert issue.watched_by?(user)

1211

assert issue.watched_by?(user)

1209

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

1212

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

1210

end

1213

end

1211

1214

1212

def test_issue_destroy

1215

def test_issue_destroy

1213

Issue.find(1).destroy

1216

Issue.find(1).destroy

1214

assert_nil Issue.find_by_id(1)

1217

assert_nil Issue.find_by_id(1)

1215

assert_nil TimeEntry.find_by_issue_id(1)

1218

assert_nil TimeEntry.find_by_issue_id(1)

1216

end

1219

end

1217

1220

1218

def test_destroying_a_deleted_issue_should_not_raise_an_error

1221

def test_destroying_a_deleted_issue_should_not_raise_an_error

1219

issue = Issue.find(1)

1222

issue = Issue.find(1)

1220

Issue.find(1).destroy

1223

Issue.find(1).destroy

1221

1224

1222

assert_nothing_raised do

1225

assert_nothing_raised do

1223

assert_no_difference 'Issue.count' do

1226

assert_no_difference 'Issue.count' do

1224

issue.destroy

1227

issue.destroy

1225

end

1228

end

1226

assert issue.destroyed?

1229

assert issue.destroyed?

1227

end

1230

end

1228

end

1231

end

1229

1232

1230

def test_destroying_a_stale_issue_should_not_raise_an_error

1233

def test_destroying_a_stale_issue_should_not_raise_an_error

1231

issue = Issue.find(1)

1234

issue = Issue.find(1)

1232

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

1235

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

1233

1236

1234

assert_nothing_raised do

1237

assert_nothing_raised do

1235

assert_difference 'Issue.count', -1 do

1238

assert_difference 'Issue.count', -1 do

1236

issue.destroy

1239

issue.destroy

1237

end

1240

end

1238

assert issue.destroyed?

1241

assert issue.destroyed?

1239

end

1242

end

1240

end

1243

end

1241

1244

1242

def test_blocked

1245

def test_blocked

1243

blocked_issue = Issue.find(9)

1246

blocked_issue = Issue.find(9)

1244

blocking_issue = Issue.find(10)

1247

blocking_issue = Issue.find(10)

1245

1248

1246

assert blocked_issue.blocked?

1249

assert blocked_issue.blocked?

1247

assert !blocking_issue.blocked?

1250

assert !blocking_issue.blocked?

1248

end

1251

end

1249

1252

1250

def test_blocked_issues_dont_allow_closed_statuses

1253

def test_blocked_issues_dont_allow_closed_statuses

1251

blocked_issue = Issue.find(9)

1254

blocked_issue = Issue.find(9)

1252

1255

1253

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

1256

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

1254

assert !allowed_statuses.empty?

1257

assert !allowed_statuses.empty?

1255

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

1258

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

1256

assert closed_statuses.empty?

1259

assert closed_statuses.empty?

1257

end

1260

end

1258

1261

1259

def test_unblocked_issues_allow_closed_statuses

1262

def test_unblocked_issues_allow_closed_statuses

1260

blocking_issue = Issue.find(10)

1263

blocking_issue = Issue.find(10)

1261

1264

1262

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

1265

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

1263

assert !allowed_statuses.empty?

1266

assert !allowed_statuses.empty?

1264

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

1267

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

1265

assert !closed_statuses.empty?

1268

assert !closed_statuses.empty?

1266

end

1269

end

1267

1270

1268

def test_rescheduling_an_issue_should_reschedule_following_issue

1271

def test_rescheduling_an_issue_should_reschedule_following_issue

1269

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

1272

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

1270

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

1273

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

1271

:subject => '-',

1274

:subject => '-',

1272

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

1275

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

1273

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

1276

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

1274

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

1277

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

1275

:subject => '-',

1278

:subject => '-',

1276

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

1279

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

1277

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

1280

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

1278

:relation_type => IssueRelation::TYPE_PRECEDES)

1281

:relation_type => IssueRelation::TYPE_PRECEDES)

1279

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

1282

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

1280

1283

1281

issue1.due_date = Date.today + 5

1284

issue1.due_date = Date.today + 5

1282

issue1.save!

1285

issue1.save!

1283

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

1286

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

1284

end

1287

end

1285

1288

1286

def test_rescheduling_a_stale_issue_should_not_raise_an_error

1289

def test_rescheduling_a_stale_issue_should_not_raise_an_error

1287

stale = Issue.find(1)

1290

stale = Issue.find(1)

1288

issue = Issue.find(1)

1291

issue = Issue.find(1)

1289

issue.subject = "Updated"

1292

issue.subject = "Updated"

1290

issue.save!

1293

issue.save!

1291

1294

1292

date = 10.days.from_now.to_date

1295

date = 10.days.from_now.to_date

1293

assert_nothing_raised do

1296

assert_nothing_raised do

1294

stale.reschedule_after(date)

1297

stale.reschedule_after(date)

1295

end

1298

end

1296

assert_equal date, stale.reload.start_date

1299

assert_equal date, stale.reload.start_date

1297

end

1300

end

1298

1301

1299

def test_overdue

1302

def test_overdue

1300

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

1303

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

1301

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

1304

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

1302

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

1305

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

1303

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

1306

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

1304

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

1307

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

1305

:status => IssueStatus.find(:first,

1308

:status => IssueStatus.find(:first,

1306

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

1309

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

1307

).overdue?

1310

).overdue?

1308

end

1311

end

1309

1312

1310

context "#behind_schedule?" do

1313

context "#behind_schedule?" do

1311

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

1314

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

1312

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

1315

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

1313

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

1316

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

1314

:done_ratio => 0).behind_schedule?

1317

:done_ratio => 0).behind_schedule?

1315

end

1318

end

1316

1319

1317

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

1320

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

1318

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

1321

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

1319

:due_date => nil,

1322

:due_date => nil,

1320

:done_ratio => 0).behind_schedule?

1323

:done_ratio => 0).behind_schedule?

1321

end

1324

end

1322

1325

1323

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

1326

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

1324

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

1327

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

1325

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

1328

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

1326

:done_ratio => 90).behind_schedule?

1329

:done_ratio => 90).behind_schedule?

1327

end

1330

end

1328

1331

1329

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

1332

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

1330

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

1333

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

1331

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

1334

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

1332

:done_ratio => 0).behind_schedule?

1335

:done_ratio => 0).behind_schedule?

1333

end

1336

end

1334

1337

1335

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

1338

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

1336

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

1339

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

1337

:due_date => Date.today,

1340

:due_date => Date.today,

1338

:done_ratio => 90).behind_schedule?

1341

:done_ratio => 90).behind_schedule?

1339

end

1342

end

1340

end

1343

end

1341

1344

1342

context "#assignable_users" do

1345

context "#assignable_users" do

1343

should "be Users" do

1346

should "be Users" do

1344

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

1347

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

1345

end

1348

end

1346

1349

1347

should "include the issue author" do

1350

should "include the issue author" do

1348

non_project_member = User.generate!

1351

non_project_member = User.generate!

1349

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

1352

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

1350

1353

1351

assert issue.assignable_users.include?(non_project_member)

1354

assert issue.assignable_users.include?(non_project_member)

1352

end

1355

end

1353

1356

1354

should "include the current assignee" do

1357

should "include the current assignee" do

1355

user = User.generate!

1358

user = User.generate!

1356

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

1359

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

1357

user.lock!

1360

user.lock!

1358

1361

1359

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

1362

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

1360

end

1363

end

1361

1364

1362

should "not show the issue author twice" do

1365

should "not show the issue author twice" do

1363

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

1366

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

1364

assert_equal 2, assignable_user_ids.length

1367

assert_equal 2, assignable_user_ids.length

1365

1368

1366

assignable_user_ids.each do |user_id|

1369

assignable_user_ids.each do |user_id|

1367

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

1370

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

1368

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

1371

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

1369

end

1372

end

1370

end

1373

end

1371

1374

1372

context "with issue_group_assignment" do

1375

context "with issue_group_assignment" do

1373

should "include groups" do

1376

should "include groups" do

1374

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

1377

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

1375

1378

1376

with_settings :issue_group_assignment => '1' do

1379

with_settings :issue_group_assignment => '1' do

1377

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

1380

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

1378

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

1381

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

1379

end

1382

end

1380

end

1383

end

1381

end

1384

end

1382

1385

1383

context "without issue_group_assignment" do

1386

context "without issue_group_assignment" do

1384

should "not include groups" do

1387

should "not include groups" do

1385

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

1388

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

1386

1389

1387

with_settings :issue_group_assignment => '0' do

1390

with_settings :issue_group_assignment => '0' do

1388

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

1391

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

1389

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

1392

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

1390

end

1393

end

1391

end

1394

end

1392

end

1395

end

1393

end

1396

end

1394

1397

1395

def test_create_should_send_email_notification

1398

def test_create_should_send_email_notification

1396

ActionMailer::Base.deliveries.clear

1399

ActionMailer::Base.deliveries.clear

1397

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

1400

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

1398

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

1401

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

1399

:priority => IssuePriority.all.first,

1402

:priority => IssuePriority.all.first,

1400

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

1403

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

1401

1404

1402

assert issue.save

1405

assert issue.save

1403

assert_equal 1, ActionMailer::Base.deliveries.size

1406

assert_equal 1, ActionMailer::Base.deliveries.size

1404

end

1407

end

1405

1408

1406

def test_stale_issue_should_not_send_email_notification

1409

def test_stale_issue_should_not_send_email_notification

1407

ActionMailer::Base.deliveries.clear

1410

ActionMailer::Base.deliveries.clear

1408

issue = Issue.find(1)

1411

issue = Issue.find(1)

1409

stale = Issue.find(1)

1412

stale = Issue.find(1)

1410

1413

1411

issue.init_journal(User.find(1))

1414

issue.init_journal(User.find(1))

1412

issue.subject = 'Subjet update'

1415

issue.subject = 'Subjet update'

1413

assert issue.save

1416

assert issue.save

1414

assert_equal 1, ActionMailer::Base.deliveries.size

1417

assert_equal 1, ActionMailer::Base.deliveries.size

1415

ActionMailer::Base.deliveries.clear

1418

ActionMailer::Base.deliveries.clear

1416

1419

1417

stale.init_journal(User.find(1))

1420

stale.init_journal(User.find(1))

1418

stale.subject = 'Another subjet update'

1421

stale.subject = 'Another subjet update'

1419

assert_raise ActiveRecord::StaleObjectError do

1422

assert_raise ActiveRecord::StaleObjectError do

1420

stale.save

1423

stale.save

1421

end

1424

end

1422

assert ActionMailer::Base.deliveries.empty?

1425

assert ActionMailer::Base.deliveries.empty?

1423

end

1426

end

1424

1427

1425

def test_journalized_description

1428

def test_journalized_description

1426

IssueCustomField.delete_all

1429

IssueCustomField.delete_all

1427

1430

1428

i = Issue.first

1431

i = Issue.first

1429

old_description = i.description

1432

old_description = i.description

1430

new_description = "This is the new description"

1433

new_description = "This is the new description"

1431

1434

1432

i.init_journal(User.find(2))

1435

i.init_journal(User.find(2))

1433

i.description = new_description

1436

i.description = new_description

1434

assert_difference 'Journal.count', 1 do

1437

assert_difference 'Journal.count', 1 do

1435

assert_difference 'JournalDetail.count', 1 do

1438

assert_difference 'JournalDetail.count', 1 do

1436

i.save!

1439

i.save!

1437

end

1440

end

1438

end

1441

end

1439

1442

1440

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

1443

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

1441

assert_equal i, detail.journal.journalized

1444

assert_equal i, detail.journal.journalized

1442

assert_equal 'attr', detail.property

1445

assert_equal 'attr', detail.property

1443

assert_equal 'description', detail.prop_key

1446

assert_equal 'description', detail.prop_key

1444

assert_equal old_description, detail.old_value

1447

assert_equal old_description, detail.old_value

1445

assert_equal new_description, detail.value

1448

assert_equal new_description, detail.value

1446

end

1449

end

1447

1450

1448

def test_blank_descriptions_should_not_be_journalized

1451

def test_blank_descriptions_should_not_be_journalized

1449

IssueCustomField.delete_all

1452

IssueCustomField.delete_all

1450

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

1453

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

1451

1454

1452

i = Issue.find(1)

1455

i = Issue.find(1)

1453

i.init_journal(User.find(2))

1456

i.init_journal(User.find(2))

1454

i.subject = "blank description"

1457

i.subject = "blank description"

1455

i.description = "\r\n"

1458

i.description = "\r\n"

1456

1459

1457

assert_difference 'Journal.count', 1 do

1460

assert_difference 'Journal.count', 1 do

1458

assert_difference 'JournalDetail.count', 1 do

1461

assert_difference 'JournalDetail.count', 1 do

1459

i.save!

1462

i.save!

1460

end

1463

end

1461

end

1464

end

1462

end

1465

end

1463

1466

1464

def test_journalized_multi_custom_field

1467

def test_journalized_multi_custom_field

1465

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

1468

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

1466

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

1469

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

1467

:tracker_ids => [1],

1470

:tracker_ids => [1],

1468

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

1471

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

1469

:multiple => true)

1472

:multiple => true)

1470

1473

1471

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

1474

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

1472

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

1475

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

1473

1476

1474

assert_difference 'Journal.count' do

1477

assert_difference 'Journal.count' do

1475

assert_difference 'JournalDetail.count' do

1478

assert_difference 'JournalDetail.count' do

1476

issue.init_journal(User.first)

1479

issue.init_journal(User.first)

1477

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

1480

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

1478

issue.save!

1481

issue.save!

1479

end

1482

end

1480

assert_difference 'JournalDetail.count' do

1483

assert_difference 'JournalDetail.count' do

1481

issue.init_journal(User.first)

1484

issue.init_journal(User.first)

1482

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

1485

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

1483

issue.save!

1486

issue.save!

1484

end

1487

end

1485

assert_difference 'JournalDetail.count', 2 do

1488

assert_difference 'JournalDetail.count', 2 do

1486

issue.init_journal(User.first)

1489

issue.init_journal(User.first)

1487

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

1490

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

1488

issue.save!

1491

issue.save!

1489

end

1492

end

1490

assert_difference 'JournalDetail.count', 2 do

1493

assert_difference 'JournalDetail.count', 2 do

1491

issue.init_journal(User.first)

1494

issue.init_journal(User.first)

1492

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

1495

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

1493

issue.save!

1496

issue.save!

1494

end

1497

end

1495

end

1498

end

1496

end

1499

end

1497

1500

1498

def test_description_eol_should_be_normalized

1501

def test_description_eol_should_be_normalized

1499

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

1502

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

1500

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

1503

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

1501

end

1504

end

1502

1505

1503

def test_saving_twice_should_not_duplicate_journal_details

1506

def test_saving_twice_should_not_duplicate_journal_details

1504

i = Issue.find(:first)

1507

i = Issue.find(:first)

1505

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

1508

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

1506

# initial changes

1509

# initial changes

1507

i.subject = 'New subject'

1510

i.subject = 'New subject'

1508

i.done_ratio = i.done_ratio + 10

1511

i.done_ratio = i.done_ratio + 10

1509

assert_difference 'Journal.count' do

1512

assert_difference 'Journal.count' do

1510

assert i.save

1513

assert i.save

1511

end

1514

end

1512

# 1 more change

1515

# 1 more change

1513

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

1516

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

1514

assert_no_difference 'Journal.count' do

1517

assert_no_difference 'Journal.count' do

1515

assert_difference 'JournalDetail.count', 1 do

1518

assert_difference 'JournalDetail.count', 1 do

1516

i.save

1519

i.save

1517

end

1520

end

1518

end

1521

end

1519

# no more change

1522

# no more change

1520

assert_no_difference 'Journal.count' do

1523

assert_no_difference 'Journal.count' do

1521

assert_no_difference 'JournalDetail.count' do

1524

assert_no_difference 'JournalDetail.count' do

1522

i.save

1525

i.save

1523

end

1526

end

1524

end

1527

end

1525

end

1528

end

1526

1529

1527

def test_all_dependent_issues

1530

def test_all_dependent_issues

1528

IssueRelation.delete_all

1531

IssueRelation.delete_all

1529

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

1532

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

1530

:issue_to => Issue.find(2),

1533

:issue_to => Issue.find(2),

1531

:relation_type => IssueRelation::TYPE_PRECEDES)

1534

:relation_type => IssueRelation::TYPE_PRECEDES)

1532

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

1535

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

1533

:issue_to => Issue.find(3),

1536

:issue_to => Issue.find(3),

1534

:relation_type => IssueRelation::TYPE_PRECEDES)

1537

:relation_type => IssueRelation::TYPE_PRECEDES)

1535

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

1538

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

1536

:issue_to => Issue.find(8),

1539

:issue_to => Issue.find(8),

1537

:relation_type => IssueRelation::TYPE_PRECEDES)

1540

:relation_type => IssueRelation::TYPE_PRECEDES)

1538

1541

1539

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

1542

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

1540

end

1543

end

1541

1544

1542

def test_all_dependent_issues_with_persistent_circular_dependency

1545

def test_all_dependent_issues_with_persistent_circular_dependency

1543

IssueRelation.delete_all

1546

IssueRelation.delete_all

1544

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

1547

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

1545

:issue_to => Issue.find(2),

1548

:issue_to => Issue.find(2),

1546

:relation_type => IssueRelation::TYPE_PRECEDES)

1549

:relation_type => IssueRelation::TYPE_PRECEDES)

1547

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

1550

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

1548

:issue_to => Issue.find(3),

1551

:issue_to => Issue.find(3),

1549

:relation_type => IssueRelation::TYPE_PRECEDES)

1552

:relation_type => IssueRelation::TYPE_PRECEDES)

1550

1553

1551

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

1554

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

1552

:issue_to => Issue.find(7),

1555

:issue_to => Issue.find(7),

1553

:relation_type => IssueRelation::TYPE_PRECEDES)

1556

:relation_type => IssueRelation::TYPE_PRECEDES)

1554

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

1557

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

1555

1558

1556

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

1559

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

1557

end

1560

end

1558

1561

1559

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

1562

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

1560

IssueRelation.delete_all

1563

IssueRelation.delete_all

1561

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

1564

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

1562

:issue_to => Issue.find(2),

1565

:issue_to => Issue.find(2),

1563

:relation_type => IssueRelation::TYPE_RELATES)

1566

:relation_type => IssueRelation::TYPE_RELATES)

1564

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

1567

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

1565

:issue_to => Issue.find(3),

1568

:issue_to => Issue.find(3),

1566

:relation_type => IssueRelation::TYPE_RELATES)

1569

:relation_type => IssueRelation::TYPE_RELATES)

1567

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

1570

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

1568

:issue_to => Issue.find(8),

1571

:issue_to => Issue.find(8),

1569

:relation_type => IssueRelation::TYPE_RELATES)

1572

:relation_type => IssueRelation::TYPE_RELATES)

1570

1573

1571

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

1574

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

1572

:issue_to => Issue.find(7),

1575

:issue_to => Issue.find(7),

1573

:relation_type => IssueRelation::TYPE_RELATES)

1576

:relation_type => IssueRelation::TYPE_RELATES)

1574

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

1577

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

1575

1578

1576

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

1579

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

1577

:issue_to => Issue.find(7),

1580

:issue_to => Issue.find(7),

1578

:relation_type => IssueRelation::TYPE_RELATES)

1581

:relation_type => IssueRelation::TYPE_RELATES)

1579

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

1582

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

1580

1583

1581

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

1584

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

1582

end

1585

end

1583

1586

1584

context "#done_ratio" do

1587

context "#done_ratio" do

1585

setup do

1588

setup do

1586

@issue = Issue.find(1)

1589

@issue = Issue.find(1)

1587

@issue_status = IssueStatus.find(1)

1590

@issue_status = IssueStatus.find(1)

1588

@issue_status.update_attribute(:default_done_ratio, 50)

1591

@issue_status.update_attribute(:default_done_ratio, 50)

1589

@issue2 = Issue.find(2)

1592

@issue2 = Issue.find(2)

1590

@issue_status2 = IssueStatus.find(2)

1593

@issue_status2 = IssueStatus.find(2)

1591

@issue_status2.update_attribute(:default_done_ratio, 0)

1594

@issue_status2.update_attribute(:default_done_ratio, 0)

1592

end

1595

end

1593

1596

1594

teardown do

1597

teardown do

1595

Setting.issue_done_ratio = 'issue_field'

1598

Setting.issue_done_ratio = 'issue_field'

1596

end

1599

end

1597

1600

1598

context "with Setting.issue_done_ratio using the issue_field" do

1601

context "with Setting.issue_done_ratio using the issue_field" do

1599

setup do

1602

setup do

1600

Setting.issue_done_ratio = 'issue_field'

1603

Setting.issue_done_ratio = 'issue_field'

1601

end

1604

end

1602

1605

1603

should "read the issue's field" do

1606

should "read the issue's field" do

1604

assert_equal 0, @issue.done_ratio

1607

assert_equal 0, @issue.done_ratio

1605

assert_equal 30, @issue2.done_ratio

1608

assert_equal 30, @issue2.done_ratio

1606

end

1609

end

1607

end

1610

end

1608

1611

1609

context "with Setting.issue_done_ratio using the issue_status" do

1612

context "with Setting.issue_done_ratio using the issue_status" do

1610

setup do

1613

setup do

1611

Setting.issue_done_ratio = 'issue_status'

1614

Setting.issue_done_ratio = 'issue_status'

1612

end

1615

end

1613

1616

1614

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

1617

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

1615

assert_equal 50, @issue.done_ratio

1618

assert_equal 50, @issue.done_ratio

1616

assert_equal 0, @issue2.done_ratio

1619

assert_equal 0, @issue2.done_ratio

1617

end

1620

end

1618

end

1621

end

1619

end

1622

end

1620

1623

1621

context "#update_done_ratio_from_issue_status" do

1624

context "#update_done_ratio_from_issue_status" do

1622

setup do

1625

setup do

1623

@issue = Issue.find(1)

1626

@issue = Issue.find(1)

1624

@issue_status = IssueStatus.find(1)

1627

@issue_status = IssueStatus.find(1)

1625

@issue_status.update_attribute(:default_done_ratio, 50)

1628

@issue_status.update_attribute(:default_done_ratio, 50)

1626

@issue2 = Issue.find(2)

1629

@issue2 = Issue.find(2)

1627

@issue_status2 = IssueStatus.find(2)

1630

@issue_status2 = IssueStatus.find(2)

1628

@issue_status2.update_attribute(:default_done_ratio, 0)

1631

@issue_status2.update_attribute(:default_done_ratio, 0)

1629

end

1632

end

1630

1633

1631

context "with Setting.issue_done_ratio using the issue_field" do

1634

context "with Setting.issue_done_ratio using the issue_field" do

1632

setup do

1635

setup do

1633

Setting.issue_done_ratio = 'issue_field'

1636

Setting.issue_done_ratio = 'issue_field'

1634

end

1637

end

1635

1638

1636

should "not change the issue" do

1639

should "not change the issue" do

1637

@issue.update_done_ratio_from_issue_status

1640

@issue.update_done_ratio_from_issue_status

1638

@issue2.update_done_ratio_from_issue_status

1641

@issue2.update_done_ratio_from_issue_status

1639

1642

1640

assert_equal 0, @issue.read_attribute(:done_ratio)

1643

assert_equal 0, @issue.read_attribute(:done_ratio)

1641

assert_equal 30, @issue2.read_attribute(:done_ratio)

1644

assert_equal 30, @issue2.read_attribute(:done_ratio)

1642

end

1645

end

1643

end

1646

end

1644

1647

1645

context "with Setting.issue_done_ratio using the issue_status" do

1648

context "with Setting.issue_done_ratio using the issue_status" do

1646

setup do

1649

setup do

1647

Setting.issue_done_ratio = 'issue_status'

1650

Setting.issue_done_ratio = 'issue_status'

1648

end

1651

end

1649

1652

1650

should "change the issue's done ratio" do

1653

should "change the issue's done ratio" do

1651

@issue.update_done_ratio_from_issue_status

1654

@issue.update_done_ratio_from_issue_status

1652

@issue2.update_done_ratio_from_issue_status

1655

@issue2.update_done_ratio_from_issue_status

1653

1656

1654

assert_equal 50, @issue.read_attribute(:done_ratio)

1657

assert_equal 50, @issue.read_attribute(:done_ratio)

1655

assert_equal 0, @issue2.read_attribute(:done_ratio)

1658

assert_equal 0, @issue2.read_attribute(:done_ratio)

1656

end

1659

end

1657

end

1660

end

1658

end

1661

end

1659

1662

1660

test "#by_tracker" do

1663

test "#by_tracker" do

1661

User.current = User.anonymous

1664

User.current = User.anonymous

1662

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

1665

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

1663

assert_equal 3, groups.size

1666

assert_equal 3, groups.size

1664

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

1667

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

1665

end

1668

end

1666

1669

1667

test "#by_version" do

1670

test "#by_version" do

1668

User.current = User.anonymous

1671

User.current = User.anonymous

1669

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

1672

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

1670

assert_equal 3, groups.size

1673

assert_equal 3, groups.size

1671

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

1674

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

1672

end

1675

end

1673

1676

1674

test "#by_priority" do

1677

test "#by_priority" do

1675

User.current = User.anonymous

1678

User.current = User.anonymous

1676

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

1679

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

1677

assert_equal 4, groups.size

1680

assert_equal 4, groups.size

1678

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

1681

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

1679

end

1682

end

1680

1683

1681

test "#by_category" do

1684

test "#by_category" do

1682

User.current = User.anonymous

1685

User.current = User.anonymous

1683

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

1686

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

1684

assert_equal 2, groups.size

1687

assert_equal 2, groups.size

1685

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

1688

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

1686

end

1689

end

1687

1690

1688

test "#by_assigned_to" do

1691

test "#by_assigned_to" do

1689

User.current = User.anonymous

1692

User.current = User.anonymous

1690

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

1693

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

1691

assert_equal 2, groups.size

1694

assert_equal 2, groups.size

1692

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

1695

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

1693

end

1696

end

1694

1697

1695

test "#by_author" do

1698

test "#by_author" do

1696

User.current = User.anonymous

1699

User.current = User.anonymous

1697

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

1700

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

1698

assert_equal 4, groups.size

1701

assert_equal 4, groups.size

1699

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

1702

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

1700

end

1703

end

1701

1704

1702

test "#by_subproject" do

1705

test "#by_subproject" do

1703

User.current = User.anonymous

1706

User.current = User.anonymous

1704

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

1707

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

1705

# Private descendant not visible

1708

# Private descendant not visible

1706

assert_equal 1, groups.size

1709

assert_equal 1, groups.size

1707

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

1710

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

1708

end

1711

end

1709

1712

1710

def test_recently_updated_scope

1713

def test_recently_updated_scope

1711

#should return the last updated issue

1714

#should return the last updated issue

1712

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

1715

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

1713

end

1716

end

1714

1717

1715

def test_on_active_projects_scope

1718

def test_on_active_projects_scope

1716

assert Project.find(2).archive

1719

assert Project.find(2).archive

1717

1720

1718

before = Issue.on_active_project.length

1721

before = Issue.on_active_project.length

1719

# test inclusion to results

1722

# test inclusion to results

1720

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

1723

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

1721

assert_equal before + 1, Issue.on_active_project.length

1724

assert_equal before + 1, Issue.on_active_project.length

1722

1725

1723

# Move to an archived project

1726

# Move to an archived project

1724

issue.project = Project.find(2)

1727

issue.project = Project.find(2)

1725

assert issue.save

1728

assert issue.save

1726

assert_equal before, Issue.on_active_project.length

1729

assert_equal before, Issue.on_active_project.length

1727

end

1730

end

1728

1731

1729

context "Issue#recipients" do

1732

context "Issue#recipients" do

1730

setup do

1733

setup do

1731

@project = Project.find(1)

1734

@project = Project.find(1)

1732

@author = User.generate!

1735

@author = User.generate!

1733

@assignee = User.generate!

1736

@assignee = User.generate!

1734

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

1737

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

1735

end

1738

end

1736

1739

1737

should "include project recipients" do

1740

should "include project recipients" do

1738

assert @project.recipients.present?

1741

assert @project.recipients.present?

1739

@project.recipients.each do |project_recipient|

1742

@project.recipients.each do |project_recipient|

1740

assert @issue.recipients.include?(project_recipient)

1743

assert @issue.recipients.include?(project_recipient)

1741

end

1744

end

1742

end

1745

end

1743

1746

1744

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

1747

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

1745

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

1748

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

1746

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

1749

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

1747

end

1750

end

1748

1751

1749

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

1752

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

1750

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

1753

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

1751

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

1754

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

1752

end

1755

end

1753

1756

1754

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

1757

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

1755

@author.update_attribute(:mail_notification, :none)

1758

@author.update_attribute(:mail_notification, :none)

1756

1759

1757

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

1760

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

1758

end

1761

end

1759

1762

1760

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

1763

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

1761

@author.update_attribute(:mail_notification, :only_assigned)

1764

@author.update_attribute(:mail_notification, :only_assigned)

1762

1765

1763

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

1766

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

1764

end

1767

end

1765

1768

1766

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

1769

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

1767

@assignee.update_attribute(:mail_notification, :only_owner)

1770

@assignee.update_attribute(:mail_notification, :only_owner)

1768

1771

1769

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

1772

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

1770

end

1773

end

1771

end

1774

end

1772

1775

1773

def test_last_journal_id_with_journals_should_return_the_journal_id

1776

def test_last_journal_id_with_journals_should_return_the_journal_id

1774

assert_equal 2, Issue.find(1).last_journal_id

1777

assert_equal 2, Issue.find(1).last_journal_id

1775

end

1778

end

1776

1779

1777

def test_last_journal_id_without_journals_should_return_nil

1780

def test_last_journal_id_without_journals_should_return_nil

1778

assert_nil Issue.find(3).last_journal_id

1781

assert_nil Issue.find(3).last_journal_id

1779

end

1782

end

1780

1783

1781

def test_journals_after_should_return_journals_with_greater_id

1784

def test_journals_after_should_return_journals_with_greater_id

1782

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

1785

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

1783

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

1786

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

1784

end

1787

end

1785

1788

1786

def test_journals_after_with_blank_arg_should_return_all_journals

1789

def test_journals_after_with_blank_arg_should_return_all_journals

1787

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

1790

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

1788

end

1791

end

1789

end

1792

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,
                                            :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')
                 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')
                 # 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)
+                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)
+                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)
+                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