jro_apps/redmine Commit - r6182:ed23149a6c18

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

:trackers, :projects_trackers,

22

:trackers, :projects_trackers,

23

:enabled_modules,

23

:enabled_modules,

24

:versions,

24

:versions,

25

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

25

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

26

:enumerations,

26

:enumerations,

27

:issues,

27

:issues,

28

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

28

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

29

:time_entries

29

:time_entries

30

31

def test_create

31

def test_create

32

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

32

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

33

assert issue.save

33

assert issue.save

34

issue.reload

34

issue.reload

35

assert_equal 1.5, issue.estimated_hours

35

assert_equal 1.5, issue.estimated_hours

36

end

36

end

37

38

def test_create_minimal

38

def test_create_minimal

39

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create')

39

issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'test_create')

40

assert issue.save

40

assert issue.save

41

assert issue.description.nil?

41

assert issue.description.nil?

42

end

42

end

43

44

def test_create_with_required_custom_field

44

def test_create_with_required_custom_field

45

field = IssueCustomField.find_by_name('Database')

45

field = IssueCustomField.find_by_name('Database')

46

field.update_attribute(:is_required, true)

46

field.update_attribute(:is_required, true)

47

48

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

48

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

49

assert issue.available_custom_fields.include?(field)

49

assert issue.available_custom_fields.include?(field)

50

# No value for the custom field

50

# No value for the custom field

51

assert !issue.save

51

assert !issue.save

52

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

52

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

53

# Blank value

53

# Blank value

54

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

54

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

55

assert !issue.save

55

assert !issue.save

56

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

56

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

57

# Invalid value

57

# Invalid value

58

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

58

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

59

assert !issue.save

59

assert !issue.save

60

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

60

assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)

61

# Valid value

61

# Valid value

62

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

62

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

63

assert issue.save

63

assert issue.save

64

issue.reload

64

issue.reload

65

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

65

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

66

end

66

end

67

68

def assert_visibility_match(user, issues)

68

def assert_visibility_match(user, issues)

69

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

69

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

70

end

70

end

71

72

def test_visible_scope_for_anonymous

72

def test_visible_scope_for_anonymous

73

# Anonymous user should see issues of public projects only

73

# Anonymous user should see issues of public projects only

74

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

74

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

75

assert issues.any?

75

assert issues.any?

76

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

76

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

77

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

77

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

78

assert_visibility_match User.anonymous, issues

78

assert_visibility_match User.anonymous, issues

79

end

79

end

80

81

def test_visible_scope_for_anonymous_with_own_issues_visibility

81

def test_visible_scope_for_anonymous_with_own_issues_visibility

82

Role.anonymous.update_attribute :issues_visibility, 'own'

82

Role.anonymous.update_attribute :issues_visibility, 'own'

83

Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')

83

Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')

84

85

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

85

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

86

assert issues.any?

86

assert issues.any?

87

assert_nil issues.detect {|issue| issue.author != User.anonymous}

87

assert_nil issues.detect {|issue| issue.author != User.anonymous}

88

assert_visibility_match User.anonymous, issues

88

assert_visibility_match User.anonymous, issues

89

end

89

end

90

91

def test_visible_scope_for_anonymous_without_view_issues_permissions

91

def test_visible_scope_for_anonymous_without_view_issues_permissions

92

# Anonymous user should not see issues without permission

92

# Anonymous user should not see issues without permission

93

Role.anonymous.remove_permission!(:view_issues)

93

Role.anonymous.remove_permission!(:view_issues)

94

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

94

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

95

assert issues.empty?

95

assert issues.empty?

96

assert_visibility_match User.anonymous, issues

96

assert_visibility_match User.anonymous, issues

97

end

97

end

98

99

def test_visible_scope_for_non_member

99

def test_visible_scope_for_non_member

100

user = User.find(9)

100

user = User.find(9)

101

assert user.projects.empty?

101

assert user.projects.empty?

102

# Non member user should see issues of public projects only

102

# Non member user should see issues of public projects only

103

issues = Issue.visible(user).all

103

issues = Issue.visible(user).all

104

assert issues.any?

104

assert issues.any?

105

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

105

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

106

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

106

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

107

assert_visibility_match user, issues

107

assert_visibility_match user, issues

108

end

108

end

109

110

def test_visible_scope_for_non_member_with_own_issues_visibility

110

def test_visible_scope_for_non_member_with_own_issues_visibility

111

Role.non_member.update_attribute :issues_visibility, 'own'

111

Role.non_member.update_attribute :issues_visibility, 'own'

112

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

112

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

113

user = User.find(9)

113

user = User.find(9)

114

115

issues = Issue.visible(user).all

115

issues = Issue.visible(user).all

116

assert issues.any?

116

assert issues.any?

117

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

117

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

118

assert_visibility_match user, issues

118

assert_visibility_match user, issues

119

end

119

end

120

121

def test_visible_scope_for_non_member_without_view_issues_permissions

121

def test_visible_scope_for_non_member_without_view_issues_permissions

122

# Non member user should not see issues without permission

122

# Non member user should not see issues without permission

123

Role.non_member.remove_permission!(:view_issues)

123

Role.non_member.remove_permission!(:view_issues)

124

user = User.find(9)

124

user = User.find(9)

125

assert user.projects.empty?

125

assert user.projects.empty?

126

issues = Issue.visible(user).all

126

issues = Issue.visible(user).all

127

assert issues.empty?

127

assert issues.empty?

128

assert_visibility_match user, issues

128

assert_visibility_match user, issues

129

end

129

end

130

131

def test_visible_scope_for_member

131

def test_visible_scope_for_member

132

user = User.find(9)

132

user = User.find(9)

133

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

133

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

134

Role.non_member.remove_permission!(:view_issues)

134

Role.non_member.remove_permission!(:view_issues)

135

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

135

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

136

issues = Issue.visible(user).all

136

issues = Issue.visible(user).all

137

assert issues.any?

137

assert issues.any?

138

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

138

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

139

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

139

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

140

assert_visibility_match user, issues

140

assert_visibility_match user, issues

141

end

141

end

142

143

def test_visible_scope_for_admin

143

def test_visible_scope_for_admin

144

user = User.find(1)

144

user = User.find(1)

145

user.members.each(&:destroy)

145

user.members.each(&:destroy)

146

assert user.projects.empty?

146

assert user.projects.empty?

147

issues = Issue.visible(user).all

147

issues = Issue.visible(user).all

148

assert issues.any?

148

assert issues.any?

149

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

149

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

150

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

150

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

151

# Admin should see private issues of other users

151

# Admin should see private issues of other users

152

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

152

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

153

assert_visibility_match user, issues

153

assert_visibility_match user, issues

154

end

154

end

155

156

def test_visible_scope_with_project

156

def test_visible_scope_with_project

157

project = Project.find(1)

157

project = Project.find(1)

158

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

158

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

159

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

159

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

160

assert_equal 1, projects.size

160

assert_equal 1, projects.size

161

assert_equal project, projects.first

161

assert_equal project, projects.first

162

end

162

end

163

164

def test_visible_scope_with_project_and_subprojects

164

def test_visible_scope_with_project_and_subprojects

165

project = Project.find(1)

165

project = Project.find(1)

166

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

166

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

167

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

167

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

168

assert projects.size > 1

168

assert projects.size > 1

169

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

169

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

170

end

170

end

171

172

def test_visible_and_nested_set_scopes

172

def test_visible_and_nested_set_scopes

173

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

173

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

174

end

174

end

175

176

def test_errors_full_messages_should_include_custom_fields_errors

176

def test_errors_full_messages_should_include_custom_fields_errors

177

field = IssueCustomField.find_by_name('Database')

177

field = IssueCustomField.find_by_name('Database')

178

179

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

179

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

180

assert issue.available_custom_fields.include?(field)

180

assert issue.available_custom_fields.include?(field)

181

# Invalid value

181

# Invalid value

182

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

182

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

183

184

assert !issue.valid?

184

assert !issue.valid?

185

assert_equal 1, issue.errors.full_messages.size

185

assert_equal 1, issue.errors.full_messages.size

186

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

186

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

187

end

187

end

188

189

def test_update_issue_with_required_custom_field

189

def test_update_issue_with_required_custom_field

190

field = IssueCustomField.find_by_name('Database')

190

field = IssueCustomField.find_by_name('Database')

191

field.update_attribute(:is_required, true)

191

field.update_attribute(:is_required, true)

192

193

issue = Issue.find(1)

193

issue = Issue.find(1)

194

assert_nil issue.custom_value_for(field)

194

assert_nil issue.custom_value_for(field)

195

assert issue.available_custom_fields.include?(field)

195

assert issue.available_custom_fields.include?(field)

196

# No change to custom values, issue can be saved

196

# No change to custom values, issue can be saved

197

assert issue.save

197

assert issue.save

198

# Blank value

198

# Blank value

199

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

199

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

200

assert !issue.save

200

assert !issue.save

201

# Valid value

201

# Valid value

202

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

202

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

203

assert issue.save

203

assert issue.save

204

issue.reload

204

issue.reload

205

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

205

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

206

end

206

end

207

208

def test_should_not_update_attributes_if_custom_fields_validation_fails

208

def test_should_not_update_attributes_if_custom_fields_validation_fails

209

issue = Issue.find(1)

209

issue = Issue.find(1)

210

field = IssueCustomField.find_by_name('Database')

210

field = IssueCustomField.find_by_name('Database')

211

assert issue.available_custom_fields.include?(field)

211

assert issue.available_custom_fields.include?(field)

212

213

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

213

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

214

issue.subject = 'Should be not be saved'

214

issue.subject = 'Should be not be saved'

215

assert !issue.save

215

assert !issue.save

216

217

issue.reload

217

issue.reload

218

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

218

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

219

end

219

end

220

221

def test_should_not_recreate_custom_values_objects_on_update

221

def test_should_not_recreate_custom_values_objects_on_update

222

field = IssueCustomField.find_by_name('Database')

222

field = IssueCustomField.find_by_name('Database')

223

224

issue = Issue.find(1)

224

issue = Issue.find(1)

225

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

225

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

226

assert issue.save

226

assert issue.save

227

custom_value = issue.custom_value_for(field)

227

custom_value = issue.custom_value_for(field)

228

issue.reload

228

issue.reload

229

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

229

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

230

assert issue.save

230

assert issue.save

231

issue.reload

231

issue.reload

232

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

232

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

233

end

233

end

234

235

def test_assigning_tracker_id_should_reload_custom_fields_values

235

def test_assigning_tracker_id_should_reload_custom_fields_values

236

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

236

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

237

assert issue.custom_field_values.empty?

237

assert issue.custom_field_values.empty?

238

issue.tracker_id = 1

238

issue.tracker_id = 1

239

assert issue.custom_field_values.any?

239

assert issue.custom_field_values.any?

240

end

240

end

241

242

def test_assigning_attributes_should_assign_tracker_id_first

242

def test_assigning_attributes_should_assign_tracker_id_first

243

attributes = ActiveSupport::OrderedHash.new

243

attributes = ActiveSupport::OrderedHash.new

244

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

244

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

245

attributes['tracker_id'] = '1'

245

attributes['tracker_id'] = '1'

246

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

246

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

247

issue.attributes = attributes

247

issue.attributes = attributes

248

assert_not_nil issue.custom_value_for(1)

248

assert_not_nil issue.custom_value_for(1)

249

assert_equal 'MySQL', issue.custom_value_for(1).value

249

assert_equal 'MySQL', issue.custom_value_for(1).value

250

end

250

end

251

252

def test_should_update_issue_with_disabled_tracker

252

def test_should_update_issue_with_disabled_tracker

253

p = Project.find(1)

253

p = Project.find(1)

254

issue = Issue.find(1)

254

issue = Issue.find(1)

255

256

p.trackers.delete(issue.tracker)

256

p.trackers.delete(issue.tracker)

257

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

257

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

258

259

issue.reload

259

issue.reload

260

issue.subject = 'New subject'

260

issue.subject = 'New subject'

261

assert issue.save

261

assert issue.save

262

end

262

end

263

264

def test_should_not_set_a_disabled_tracker

264

def test_should_not_set_a_disabled_tracker

265

p = Project.find(1)

265

p = Project.find(1)

266

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

266

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

267

268

issue = Issue.find(1)

268

issue = Issue.find(1)

269

issue.tracker_id = 2

269

issue.tracker_id = 2

270

issue.subject = 'New subject'

270

issue.subject = 'New subject'

271

assert !issue.save

271

assert !issue.save

272

assert_not_nil issue.errors.on(:tracker_id)

272

assert_not_nil issue.errors.on(:tracker_id)

273

end

273

end

274

275

def test_category_based_assignment

275

def test_category_based_assignment

276

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)

276

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)

277

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

277

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

278

end

278

end

279

280

def test_new_statuses_allowed_to

280

def test_new_statuses_allowed_to

281

Workflow.delete_all

281

Workflow.delete_all

282

283

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)

283

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)

284

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)

284

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)

285

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)

285

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)

286

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 5, :author => true, :assignee => true)

286

Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 5, :author => true, :assignee => true)

287

status = IssueStatus.find(1)

287

status = IssueStatus.find(1)

288

role = Role.find(1)

288

role = Role.find(1)

289

tracker = Tracker.find(1)

289

tracker = Tracker.find(1)

290

user = User.find(2)

290

user = User.find(2)

291

292

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

292

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

293

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

293

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

294

295

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)

295

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user)

296

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

296

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

297

298

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)

298

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)

299

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

299

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

300

301

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)

301

issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :author => user, :assigned_to => user)

302

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

302

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

303

end

303

end

304

305

def test_copy

305

def test_copy

306

issue = Issue.new.copy_from(1)

306

issue = Issue.new.copy_from(1)

307

assert issue.save

307

assert issue.save

308

issue.reload

308

issue.reload

309

orig = Issue.find(1)

309

orig = Issue.find(1)

310

assert_equal orig.subject, issue.subject

310

assert_equal orig.subject, issue.subject

311

assert_equal orig.tracker, issue.tracker

311

assert_equal orig.tracker, issue.tracker

312

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

312

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

313

end

313

end

314

315

def test_copy_should_copy_status

315

def test_copy_should_copy_status

316

orig = Issue.find(8)

316

orig = Issue.find(8)

317

assert orig.status != IssueStatus.default

317

assert orig.status != IssueStatus.default

318

319

issue = Issue.new.copy_from(orig)

319

issue = Issue.new.copy_from(orig)

320

assert issue.save

320

assert issue.save

321

issue.reload

321

issue.reload

322

assert_equal orig.status, issue.status

322

assert_equal orig.status, issue.status

323

end

323

end

324

325

def test_should_close_duplicates

325

def test_should_close_duplicates

326

# Create 3 issues

326

# Create 3 issues

327

issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')

327

issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')

328

assert issue1.save

328

assert issue1.save

329

issue2 = issue1.clone

329

issue2 = issue1.clone

330

assert issue2.save

330

assert issue2.save

331

issue3 = issue1.clone

331

issue3 = issue1.clone

332

assert issue3.save

332

assert issue3.save

333

334

# 2 is a dupe of 1

334

# 2 is a dupe of 1

335

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

335

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

336

# And 3 is a dupe of 2

336

# And 3 is a dupe of 2

337

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

337

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

338

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

338

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

339

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

339

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

340

341

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

341

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

342

343

# Closing issue 1

343

# Closing issue 1

344

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

344

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

345

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

345

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

346

assert issue1.save

346

assert issue1.save

347

# 2 and 3 should be also closed

347

# 2 and 3 should be also closed

348

assert issue2.reload.closed?

348

assert issue2.reload.closed?

349

assert issue3.reload.closed?

349

assert issue3.reload.closed?

350

end

350

end

351

352

def test_should_not_close_duplicated_issue

352

def test_should_not_close_duplicated_issue

353

# Create 3 issues

353

# Create 3 issues

354

issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')

354

issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')

355

assert issue1.save

355

assert issue1.save

356

issue2 = issue1.clone

356

issue2 = issue1.clone

357

assert issue2.save

357

assert issue2.save

358

359

# 2 is a dupe of 1

359

# 2 is a dupe of 1

360

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

360

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

361

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

361

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

362

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

362

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

363

364

# Closing issue 2

364

# Closing issue 2

365

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

365

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

366

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

366

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

367

assert issue2.save

367

assert issue2.save

368

# 1 should not be also closed

368

# 1 should not be also closed

369

assert !issue1.reload.closed?

369

assert !issue1.reload.closed?

370

end

370

end

371

372

def test_assignable_versions

372

def test_assignable_versions

373

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

373

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

374

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

374

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

375

end

375

end

376

377

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

377

def test_should_not_be_able_to_assign_a_new_issue_to_a_closed_version

378

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

378

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

379

assert !issue.save

379

assert !issue.save

380

assert_not_nil issue.errors.on(:fixed_version_id)

380

assert_not_nil issue.errors.on(:fixed_version_id)

381

end

381

end

382

383

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

383

def test_should_not_be_able_to_assign_a_new_issue_to_a_locked_version

384

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

384

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

385

assert !issue.save

385

assert !issue.save

386

assert_not_nil issue.errors.on(:fixed_version_id)

386

assert_not_nil issue.errors.on(:fixed_version_id)

387

end

387

end

388

389

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

389

def test_should_be_able_to_assign_a_new_issue_to_an_open_version

390

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

390

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

391

assert issue.save

391

assert issue.save

392

end

392

end

393

394

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

394

def test_should_be_able_to_update_an_issue_assigned_to_a_closed_version

395

issue = Issue.find(11)

395

issue = Issue.find(11)

396

assert_equal 'closed', issue.fixed_version.status

396

assert_equal 'closed', issue.fixed_version.status

397

issue.subject = 'Subject changed'

397

issue.subject = 'Subject changed'

398

assert issue.save

398

assert issue.save

399

end

399

end

400

401

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

401

def test_should_not_be_able_to_reopen_an_issue_assigned_to_a_closed_version

402

issue = Issue.find(11)

402

issue = Issue.find(11)

403

issue.status_id = 1

403

issue.status_id = 1

404

assert !issue.save

404

assert !issue.save

405

assert_not_nil issue.errors.on_base

405

assert_not_nil issue.errors.on_base

406

end

406

end

407

408

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

408

def test_should_be_able_to_reopen_and_reassign_an_issue_assigned_to_a_closed_version

409

issue = Issue.find(11)

409

issue = Issue.find(11)

410

issue.status_id = 1

410

issue.status_id = 1

411

issue.fixed_version_id = 3

411

issue.fixed_version_id = 3

412

assert issue.save

412

assert issue.save

413

end

413

end

414

415

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

415

def test_should_be_able_to_reopen_an_issue_assigned_to_a_locked_version

416

issue = Issue.find(12)

416

issue = Issue.find(12)

417

assert_equal 'locked', issue.fixed_version.status

417

assert_equal 'locked', issue.fixed_version.status

418

issue.status_id = 1

418

issue.status_id = 1

419

assert issue.save

419

assert issue.save

420

end

420

end

421

422

def test_move_to_another_project_with_same_category

422

def test_move_to_another_project_with_same_category

423

issue = Issue.find(1)

423

issue = Issue.find(1)

424

assert issue.move_to_project(Project.find(2))

424

assert issue.move_to_project(Project.find(2))

425

issue.reload

425

issue.reload

426

assert_equal 2, issue.project_id

426

assert_equal 2, issue.project_id

427

# Category changes

427

# Category changes

428

assert_equal 4, issue.category_id

428

assert_equal 4, issue.category_id

429

# Make sure time entries were move to the target project

429

# Make sure time entries were move to the target project

430

assert_equal 2, issue.time_entries.first.project_id

430

assert_equal 2, issue.time_entries.first.project_id

431

end

431

end

432

433

def test_move_to_another_project_without_same_category

433

def test_move_to_another_project_without_same_category

434

issue = Issue.find(2)

434

issue = Issue.find(2)

435

assert issue.move_to_project(Project.find(2))

435

assert issue.move_to_project(Project.find(2))

436

issue.reload

436

issue.reload

437

assert_equal 2, issue.project_id

437

assert_equal 2, issue.project_id

438

# Category cleared

438

# Category cleared

439

assert_nil issue.category_id

439

assert_nil issue.category_id

440

end

440

end

441

442

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

442

def test_move_to_another_project_should_clear_fixed_version_when_not_shared

443

issue = Issue.find(1)

443

issue = Issue.find(1)

444

issue.update_attribute(:fixed_version_id, 1)

444

issue.update_attribute(:fixed_version_id, 1)

445

assert issue.move_to_project(Project.find(2))

445

assert issue.move_to_project(Project.find(2))

446

issue.reload

446

issue.reload

447

assert_equal 2, issue.project_id

447

assert_equal 2, issue.project_id

448

# Cleared fixed_version

448

# Cleared fixed_version

449

assert_equal nil, issue.fixed_version

449

assert_equal nil, issue.fixed_version

450

end

450

end

451

452

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

452

def test_move_to_another_project_should_keep_fixed_version_when_shared_with_the_target_project

453

issue = Issue.find(1)

453

issue = Issue.find(1)

454

issue.update_attribute(:fixed_version_id, 4)

454

issue.update_attribute(:fixed_version_id, 4)

455

assert issue.move_to_project(Project.find(5))

455

assert issue.move_to_project(Project.find(5))

456

issue.reload

456

issue.reload

457

assert_equal 5, issue.project_id

457

assert_equal 5, issue.project_id

458

# Keep fixed_version

458

# Keep fixed_version

459

assert_equal 4, issue.fixed_version_id

459

assert_equal 4, issue.fixed_version_id

460

end

460

end

461

462

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

462

def test_move_to_another_project_should_clear_fixed_version_when_not_shared_with_the_target_project

463

issue = Issue.find(1)

463

issue = Issue.find(1)

464

issue.update_attribute(:fixed_version_id, 1)

464

issue.update_attribute(:fixed_version_id, 1)

465

assert issue.move_to_project(Project.find(5))

465

assert issue.move_to_project(Project.find(5))

466

issue.reload

466

issue.reload

467

assert_equal 5, issue.project_id

467

assert_equal 5, issue.project_id

468

# Cleared fixed_version

468

# Cleared fixed_version

469

assert_equal nil, issue.fixed_version

469

assert_equal nil, issue.fixed_version

470

end

470

end

471

472

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

472

def test_move_to_another_project_should_keep_fixed_version_when_shared_systemwide

473

issue = Issue.find(1)

473

issue = Issue.find(1)

474

issue.update_attribute(:fixed_version_id, 7)

474

issue.update_attribute(:fixed_version_id, 7)

475

assert issue.move_to_project(Project.find(2))

475

assert issue.move_to_project(Project.find(2))

476

issue.reload

476

issue.reload

477

assert_equal 2, issue.project_id

477

assert_equal 2, issue.project_id

478

# Keep fixed_version

478

# Keep fixed_version

479

assert_equal 7, issue.fixed_version_id

479

assert_equal 7, issue.fixed_version_id

480

end

480

end

481

482

def test_move_to_another_project_with_disabled_tracker

482

def test_move_to_another_project_with_disabled_tracker

483

issue = Issue.find(1)

483

issue = Issue.find(1)

484

target = Project.find(2)

484

target = Project.find(2)

485

target.tracker_ids = [3]

485

target.tracker_ids = [3]

486

target.save

486

target.save

487

assert_equal false, issue.move_to_project(target)

487

assert_equal false, issue.move_to_project(target)

488

issue.reload

488

issue.reload

489

assert_equal 1, issue.project_id

489

assert_equal 1, issue.project_id

490

end

490

end

491

492

def test_copy_to_the_same_project

492

def test_copy_to_the_same_project

493

issue = Issue.find(1)

493

issue = Issue.find(1)

494

copy = nil

494

copy = nil

495

assert_difference 'Issue.count' do

495

assert_difference 'Issue.count' do

496

copy = issue.move_to_project(issue.project, nil, :copy => true)

496

copy = issue.move_to_project(issue.project, nil, :copy => true)

497

end

497

end

498

assert_kind_of Issue, copy

498

assert_kind_of Issue, copy

499

assert_equal issue.project, copy.project

499

assert_equal issue.project, copy.project

500

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

500

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

501

end

501

end

502

503

def test_copy_to_another_project_and_tracker

503

def test_copy_to_another_project_and_tracker

504

issue = Issue.find(1)

504

issue = Issue.find(1)

505

copy = nil

505

copy = nil

506

assert_difference 'Issue.count' do

506

assert_difference 'Issue.count' do

507

copy = issue.move_to_project(Project.find(3), Tracker.find(2), :copy => true)

507

copy = issue.move_to_project(Project.find(3), Tracker.find(2), :copy => true)

508

end

508

end

509

copy.reload

509

copy.reload

510

assert_kind_of Issue, copy

510

assert_kind_of Issue, copy

511

assert_equal Project.find(3), copy.project

511

assert_equal Project.find(3), copy.project

512

assert_equal Tracker.find(2), copy.tracker

512

assert_equal Tracker.find(2), copy.tracker

513

# Custom field #2 is not associated with target tracker

513

# Custom field #2 is not associated with target tracker

514

assert_nil copy.custom_value_for(2)

514

assert_nil copy.custom_value_for(2)

515

end

515

end

516

517

context "#move_to_project" do

517

context "#move_to_project" do

518

context "as a copy" do

518

context "as a copy" do

519

setup do

519

setup do

520

@issue = Issue.find(1)

520

@issue = Issue.find(1)

521

@copy = nil

521

@copy = nil

522

end

522

end

523

524

should "not create a journal" do

524

should "not create a journal" do

525

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})

525

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})

526

assert_equal 0, @copy.reload.journals.size

526

assert_equal 0, @copy.reload.journals.size

527

end

527

end

528

529

should "allow assigned_to changes" do

529

should "allow assigned_to changes" do

530

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})

530

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})

531

assert_equal 3, @copy.assigned_to_id

531

assert_equal 3, @copy.assigned_to_id

532

end

532

end

533

534

should "allow status changes" do

534

should "allow status changes" do

535

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:status_id => 2}})

535

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:status_id => 2}})

536

assert_equal 2, @copy.status_id

536

assert_equal 2, @copy.status_id

537

end

537

end

538

539

should "allow start date changes" do

539

should "allow start date changes" do

540

date = Date.today

540

date = Date.today

541

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})

541

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})

542

assert_equal date, @copy.start_date

542

assert_equal date, @copy.start_date

543

end

543

end

544

545

should "allow due date changes" do

545

should "allow due date changes" do

546

date = Date.today

546

date = Date.today

547

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:due_date => date}})

547

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:due_date => date}})

548

549

assert_equal date, @copy.due_date

549

assert_equal date, @copy.due_date

550

end

550

end

551

552

should "set current user as author" do

552

should "set current user as author" do

553

User.current = User.find(9)

553

User.current = User.find(9)

554

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}})

554

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}})

555

556

assert_equal User.current, @copy.author

556

assert_equal User.current, @copy.author

557

end

557

end

558

559

should "keep journal notes" do

559

should "keep journal notes" do

560

date = Date.today

560

date = Date.today

561

notes = "Notes added when copying"

561

notes = "Notes added when copying"

562

User.current = User.find(9)

562

User.current = User.find(9)

563

@issue.init_journal(User.current, notes)

563

@issue.init_journal(User.current, notes)

564

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})

564

@copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})

565

566

assert_equal 1, @copy.journals.size

566

assert_equal 1, @copy.journals.size

567

journal = @copy.journals.first

567

journal = @copy.journals.first

568

assert_equal 0, journal.details.size

568

assert_equal 0, journal.details.size

569

assert_equal notes, journal.notes

569

assert_equal notes, journal.notes

570

end

570

end

571

end

571

end

572

end

572

end

573

574

def test_recipients_should_not_include_users_that_cannot_view_the_issue

574

def test_recipients_should_not_include_users_that_cannot_view_the_issue

575

issue = Issue.find(12)

575

issue = Issue.find(12)

576

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

576

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

577

# move the issue to a private project

577

# move the issue to a private project

578

copy = issue.move_to_project(Project.find(5), Tracker.find(2), :copy => true)

578

copy = issue.move_to_project(Project.find(5), Tracker.find(2), :copy => true)

579

# author is not a member of project anymore

579

# author is not a member of project anymore

580

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

580

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

581

end

581

end

582

583

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

583

def test_watcher_recipients_should_not_include_users_that_cannot_view_the_issue

584

user = User.find(3)

584

user = User.find(3)

585

issue = Issue.find(9)

585

issue = Issue.find(9)

586

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

586

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

587

assert issue.watched_by?(user)

587

assert issue.watched_by?(user)

588

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

588

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

589

end

589

end

590

591

def test_issue_destroy

591

def test_issue_destroy

592

Issue.find(1).destroy

592

Issue.find(1).destroy

593

assert_nil Issue.find_by_id(1)

593

assert_nil Issue.find_by_id(1)

594

assert_nil TimeEntry.find_by_issue_id(1)

594

assert_nil TimeEntry.find_by_issue_id(1)

595

end

595

end

596

597

def test_blocked

597

def test_blocked

598

blocked_issue = Issue.find(9)

598

blocked_issue = Issue.find(9)

599

blocking_issue = Issue.find(10)

599

blocking_issue = Issue.find(10)

600

601

assert blocked_issue.blocked?

601

assert blocked_issue.blocked?

602

assert !blocking_issue.blocked?

602

assert !blocking_issue.blocked?

603

end

603

end

604

605

def test_blocked_issues_dont_allow_closed_statuses

605

def test_blocked_issues_dont_allow_closed_statuses

606

blocked_issue = Issue.find(9)

606

blocked_issue = Issue.find(9)

607

608

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

608

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

609

assert !allowed_statuses.empty?

609

assert !allowed_statuses.empty?

610

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

610

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

611

assert closed_statuses.empty?

611

assert closed_statuses.empty?

612

end

612

end

613

614

def test_unblocked_issues_allow_closed_statuses

614

def test_unblocked_issues_allow_closed_statuses

615

blocking_issue = Issue.find(10)

615

blocking_issue = Issue.find(10)

616

617

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

617

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

618

assert !allowed_statuses.empty?

618

assert !allowed_statuses.empty?

619

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

619

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

620

assert !closed_statuses.empty?

620

assert !closed_statuses.empty?

621

end

621

end

622

623

def test_rescheduling_an_issue_should_reschedule_following_issue

623

def test_rescheduling_an_issue_should_reschedule_following_issue

624

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)

624

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)

625

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)

625

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)

626

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

626

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

627

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

627

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

628

629

issue1.due_date = Date.today + 5

629

issue1.due_date = Date.today + 5

630

issue1.save!

630

issue1.save!

631

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

631

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

632

end

632

end

633

634

def test_overdue

634

def test_overdue

635

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

635

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

636

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

636

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

637

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

637

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

638

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

638

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

639

assert !Issue.new(:due_date => 1.day.ago.to_date, :status => IssueStatus.find(:first, :conditions => {:is_closed => true})).overdue?

639

assert !Issue.new(:due_date => 1.day.ago.to_date, :status => IssueStatus.find(:first, :conditions => {:is_closed => true})).overdue?

640

end

640

end

641

642

context "#behind_schedule?" do

642

context "#behind_schedule?" do

643

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

643

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

644

assert !Issue.new(:start_date => nil, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?

644

assert !Issue.new(:start_date => nil, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?

645

end

645

end

646

647

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

647

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

648

assert !Issue.new(:start_date => 1.day.from_now.to_date, :due_date => nil, :done_ratio => 0).behind_schedule?

648

assert !Issue.new(:start_date => 1.day.from_now.to_date, :due_date => nil, :done_ratio => 0).behind_schedule?

649

end

649

end

650

651

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

651

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

652

assert !Issue.new(:start_date => 50.days.ago.to_date, :due_date => 50.days.from_now.to_date, :done_ratio => 90).behind_schedule?

652

assert !Issue.new(:start_date => 50.days.ago.to_date, :due_date => 50.days.from_now.to_date, :done_ratio => 90).behind_schedule?

653

end

653

end

654

655

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

655

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

656

assert Issue.new(:start_date => 1.day.ago.to_date, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?

656

assert Issue.new(:start_date => 1.day.ago.to_date, :due_date => 1.day.from_now.to_date, :done_ratio => 0).behind_schedule?

657

end

657

end

658

659

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

659

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

660

assert Issue.new(:start_date => 100.days.ago.to_date, :due_date => Date.today, :done_ratio => 90).behind_schedule?

660

assert Issue.new(:start_date => 100.days.ago.to_date, :due_date => Date.today, :done_ratio => 90).behind_schedule?

661

end

661

end

662

end

662

end

663

664

context "#assignable_users" do

664

context "#assignable_users" do

665

should "be Users" do

665

should "be Users" do

666

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

666

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

667

end

667

end

668

669

should "include the issue author" do

669

should "include the issue author" do

670

project = Project.find(1)

670

project = Project.find(1)

671

non_project_member = User.generate!

671

non_project_member = User.generate!

672

issue = Issue.generate_for_project!(project, :author => non_project_member)

672

issue = Issue.generate_for_project!(project, :author => non_project_member)

673

674

assert issue.assignable_users.include?(non_project_member)

674

assert issue.assignable_users.include?(non_project_member)

675

end

675

end

676

677

should "not show the issue author twice" do

677

should "not show the issue author twice" do

678

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

678

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

679

assert_equal 2, assignable_user_ids.length

679

assert_equal 2, assignable_user_ids.length

680

681

assignable_user_ids.each do |user_id|

681

assignable_user_ids.each do |user_id|

682

assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once"

682

assert_equal 1, assignable_user_ids.select {|i| i == user_id}.length, "User #{user_id} appears more or less than once"

683

end

683

end

684

end

684

end

685

end

685

end

686

687

def test_create_should_send_email_notification

687

def test_create_should_send_email_notification

688

ActionMailer::Base.deliveries.clear

688

ActionMailer::Base.deliveries.clear

689

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

689

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

690

691

assert issue.save

691

assert issue.save

692

assert_equal 1, ActionMailer::Base.deliveries.size

692

assert_equal 1, ActionMailer::Base.deliveries.size

693

end

693

end

694

695

def test_stale_issue_should_not_send_email_notification

695

def test_stale_issue_should_not_send_email_notification

696

ActionMailer::Base.deliveries.clear

696

ActionMailer::Base.deliveries.clear

697

issue = Issue.find(1)

697

issue = Issue.find(1)

698

stale = Issue.find(1)

698

stale = Issue.find(1)

699

700

issue.init_journal(User.find(1))

700

issue.init_journal(User.find(1))

701

issue.subject = 'Subjet update'

701

issue.subject = 'Subjet update'

702

assert issue.save

702

assert issue.save

703

assert_equal 1, ActionMailer::Base.deliveries.size

703

assert_equal 1, ActionMailer::Base.deliveries.size

704

ActionMailer::Base.deliveries.clear

704

ActionMailer::Base.deliveries.clear

705

706

stale.init_journal(User.find(1))

706

stale.init_journal(User.find(1))

707

stale.subject = 'Another subjet update'

707

stale.subject = 'Another subjet update'

708

assert_raise ActiveRecord::StaleObjectError do

708

assert_raise ActiveRecord::StaleObjectError do

709

stale.save

709

stale.save

710

end

710

end

711

assert ActionMailer::Base.deliveries.empty?

711

assert ActionMailer::Base.deliveries.empty?

712

end

712

end

713

714

def test_journalized_description

714

def test_journalized_description

715

IssueCustomField.delete_all

715

IssueCustomField.delete_all

716

717

i = Issue.first

717

i = Issue.first

718

old_description = i.description

718

old_description = i.description

719

new_description = "This is the new description"

719

new_description = "This is the new description"

720

721

i.init_journal(User.find(2))

721

i.init_journal(User.find(2))

722

i.description = new_description

722

i.description = new_description

723

assert_difference 'Journal.count', 1 do

723

assert_difference 'Journal.count', 1 do

724

assert_difference 'JournalDetail.count', 1 do

724

assert_difference 'JournalDetail.count', 1 do

725

i.save!

725

i.save!

726

end

726

end

727

end

727

end

728

729

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

729

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

730

assert_equal i, detail.journal.journalized

730

assert_equal i, detail.journal.journalized

731

assert_equal 'attr', detail.property

731

assert_equal 'attr', detail.property

732

assert_equal 'description', detail.prop_key

732

assert_equal 'description', detail.prop_key

733

assert_equal old_description, detail.old_value

733

assert_equal old_description, detail.old_value

734

assert_equal new_description, detail.value

734

assert_equal new_description, detail.value

735

end

735

end

736

737

def test_blank_descriptions_should_not_be_journalized

737

def test_blank_descriptions_should_not_be_journalized

738

IssueCustomField.delete_all

738

IssueCustomField.delete_all

739

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

739

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

740

741

i = Issue.find(1)

741

i = Issue.find(1)

742

i.init_journal(User.find(2))

742

i.init_journal(User.find(2))

743

i.subject = "blank description"

743

i.subject = "blank description"

744

i.description = "\r\n"

744

i.description = "\r\n"

745

746

assert_difference 'Journal.count', 1 do

746

assert_difference 'Journal.count', 1 do

747

assert_difference 'JournalDetail.count', 1 do

747

assert_difference 'JournalDetail.count', 1 do

748

i.save!

748

i.save!

749

end

749

end

750

end

750

end

751

end

751

end

752

753

def test_description_eol_should_be_normalized

753

def test_description_eol_should_be_normalized

754

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

754

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

755

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

755

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

756

end

756

end

757

758

def test_saving_twice_should_not_duplicate_journal_details

758

def test_saving_twice_should_not_duplicate_journal_details

759

i = Issue.find(:first)

759

i = Issue.find(:first)

760

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

760

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

761

# initial changes

761

# initial changes

762

i.subject = 'New subject'

762

i.subject = 'New subject'

763

i.done_ratio = i.done_ratio + 10

763

i.done_ratio = i.done_ratio + 10

764

assert_difference 'Journal.count' do

764

assert_difference 'Journal.count' do

765

assert i.save

765

assert i.save

766

end

766

end

767

# 1 more change

767

# 1 more change

768

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

768

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

769

assert_no_difference 'Journal.count' do

769

assert_no_difference 'Journal.count' do

770

assert_difference 'JournalDetail.count', 1 do

770

assert_difference 'JournalDetail.count', 1 do

771

i.save

771

i.save

772

end

772

end

773

end

773

end

774

# no more change

774

# no more change

775

assert_no_difference 'Journal.count' do

775

assert_no_difference 'Journal.count' do

776

assert_no_difference 'JournalDetail.count' do

776

assert_no_difference 'JournalDetail.count' do

777

i.save

777

i.save

778

end

778

end

779

end

779

end

780

end

780

end

781

782

def test_all_dependent_issues

782

def test_all_dependent_issues

783

IssueRelation.delete_all

783

IssueRelation.delete_all

784

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

784

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

785

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)

785

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)

786

assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_PRECEDES)

786

assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_PRECEDES)

787

788

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

788

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

789

end

789

end

790

791

def test_all_dependent_issues_with_persistent_circular_dependency

791

def test_all_dependent_issues_with_persistent_circular_dependency

792

IssueRelation.delete_all

792

IssueRelation.delete_all

793

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

793

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

794

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)

794

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_PRECEDES)

795

# Validation skipping

795

# Validation skipping

796

assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false)

796

assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false)

797

798

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

798

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

799

end

799

end

800

801

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

801

def test_all_dependent_issues_with_persistent_multiple_circular_dependencies

802

IssueRelation.delete_all

802

IssueRelation.delete_all

803

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

803

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

804

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_RELATES)

804

assert IssueRelation.create!(:issue_from => Issue.find(2), :issue_to => Issue.find(3), :relation_type => IssueRelation::TYPE_RELATES)

805

assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_RELATES)

805

assert IssueRelation.create!(:issue_from => Issue.find(3), :issue_to => Issue.find(8), :relation_type => IssueRelation::TYPE_RELATES)

806

# Validation skipping

806

# Validation skipping

807

assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false)

807

assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false)

808

assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false)

808

assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false)

809

810

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

810

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

811

end

811

end

812

813

context "#done_ratio" do

813

context "#done_ratio" do

814

setup do

814

setup do

815

@issue = Issue.find(1)

815

@issue = Issue.find(1)

816

@issue_status = IssueStatus.find(1)

816

@issue_status = IssueStatus.find(1)

817

@issue_status.update_attribute(:default_done_ratio, 50)

817

@issue_status.update_attribute(:default_done_ratio, 50)

818

@issue2 = Issue.find(2)

818

@issue2 = Issue.find(2)

819

@issue_status2 = IssueStatus.find(2)

819

@issue_status2 = IssueStatus.find(2)

820

@issue_status2.update_attribute(:default_done_ratio, 0)

820

@issue_status2.update_attribute(:default_done_ratio, 0)

821

end

821

end

822

823

context "with Setting.issue_done_ratio using the issue_field" do

823

context "with Setting.issue_done_ratio using the issue_field" do

824

setup do

824

setup do

825

Setting.issue_done_ratio = 'issue_field'

825

Setting.issue_done_ratio = 'issue_field'

826

end

826

end

827

828

should "read the issue's field" do

828

should "read the issue's field" do

829

assert_equal 0, @issue.done_ratio

829

assert_equal 0, @issue.done_ratio

830

assert_equal 30, @issue2.done_ratio

830

assert_equal 30, @issue2.done_ratio

831

end

831

end

832

end

832

end

833

834

context "with Setting.issue_done_ratio using the issue_status" do

834

context "with Setting.issue_done_ratio using the issue_status" do

835

setup do

835

setup do

836

Setting.issue_done_ratio = 'issue_status'

836

Setting.issue_done_ratio = 'issue_status'

837

end

837

end

838

839

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

839

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

840

assert_equal 50, @issue.done_ratio

840

assert_equal 50, @issue.done_ratio

841

assert_equal 0, @issue2.done_ratio

841

assert_equal 0, @issue2.done_ratio

842

end

842

end

843

end

843

end

844

end

844

end

845

846

context "#update_done_ratio_from_issue_status" do

846

context "#update_done_ratio_from_issue_status" do

847

setup do

847

setup do

848

@issue = Issue.find(1)

848

@issue = Issue.find(1)

849

@issue_status = IssueStatus.find(1)

849

@issue_status = IssueStatus.find(1)

850

@issue_status.update_attribute(:default_done_ratio, 50)

850

@issue_status.update_attribute(:default_done_ratio, 50)

851

@issue2 = Issue.find(2)

851

@issue2 = Issue.find(2)

852

@issue_status2 = IssueStatus.find(2)

852

@issue_status2 = IssueStatus.find(2)

853

@issue_status2.update_attribute(:default_done_ratio, 0)

853

@issue_status2.update_attribute(:default_done_ratio, 0)

854

end

854

end

855

856

context "with Setting.issue_done_ratio using the issue_field" do

856

context "with Setting.issue_done_ratio using the issue_field" do

857

setup do

857

setup do

858

Setting.issue_done_ratio = 'issue_field'

858

Setting.issue_done_ratio = 'issue_field'

859

end

859

end

860

861

should "not change the issue" do

861

should "not change the issue" do

862

@issue.update_done_ratio_from_issue_status

862

@issue.update_done_ratio_from_issue_status

863

@issue2.update_done_ratio_from_issue_status

863

@issue2.update_done_ratio_from_issue_status

864

865

assert_equal 0, @issue.read_attribute(:done_ratio)

865

assert_equal 0, @issue.read_attribute(:done_ratio)

866

assert_equal 30, @issue2.read_attribute(:done_ratio)

866

assert_equal 30, @issue2.read_attribute(:done_ratio)

867

end

867

end

868

end

868

end

869

870

context "with Setting.issue_done_ratio using the issue_status" do

870

context "with Setting.issue_done_ratio using the issue_status" do

871

setup do

871

setup do

872

Setting.issue_done_ratio = 'issue_status'

872

Setting.issue_done_ratio = 'issue_status'

873

end

873

end

874

875

should "change the issue's done ratio" do

875

should "change the issue's done ratio" do

876

@issue.update_done_ratio_from_issue_status

876

@issue.update_done_ratio_from_issue_status

877

@issue2.update_done_ratio_from_issue_status

877

@issue2.update_done_ratio_from_issue_status

878

879

assert_equal 50, @issue.read_attribute(:done_ratio)

879

assert_equal 50, @issue.read_attribute(:done_ratio)

880

assert_equal 0, @issue2.read_attribute(:done_ratio)

880

assert_equal 0, @issue2.read_attribute(:done_ratio)

881

end

881

end

882

end

882

end

883

end

883

end

884

885

test "#by_tracker" do

885

test "#by_tracker" do

886

User.current = User.anonymous

886

User.current = User.anonymous

887

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

887

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

888

assert_equal 3, groups.size

888

assert_equal 3, groups.size

889

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

889

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

890

end

890

end

891

892

test "#by_version" do

892

test "#by_version" do

893

User.current = User.anonymous

893

User.current = User.anonymous

894

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

894

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

895

assert_equal 3, groups.size

895

assert_equal 3, groups.size

896

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

896

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

897

end

897

end

898

899

test "#by_priority" do

899

test "#by_priority" do

900

User.current = User.anonymous

900

User.current = User.anonymous

901

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

901

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

902

assert_equal 4, groups.size

902

assert_equal 4, groups.size

903

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

903

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

904

end

904

end

905

906

test "#by_category" do

906

test "#by_category" do

907

User.current = User.anonymous

907

User.current = User.anonymous

908

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

908

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

909

assert_equal 2, groups.size

909

assert_equal 2, groups.size

910

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

910

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

911

end

911

end

912

913

test "#by_assigned_to" do

913

test "#by_assigned_to" do

914

User.current = User.anonymous

914

User.current = User.anonymous

915

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

915

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

916

assert_equal 2, groups.size

916

assert_equal 2, groups.size

917

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

917

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

918

end

918

end

919

920

test "#by_author" do

920

test "#by_author" do

921

User.current = User.anonymous

921

User.current = User.anonymous

922

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

922

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

923

assert_equal 4, groups.size

923

assert_equal 4, groups.size

924

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

924

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

925

end

925

end

926

927

test "#by_subproject" do

927

test "#by_subproject" do

928

User.current = User.anonymous

928

User.current = User.anonymous

929

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

929

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

930

# Private descendant not visible

930

# Private descendant not visible

931

assert_equal 1, groups.size

931

assert_equal 1, groups.size

932

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

932

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

933

end

933

end

934

935

context ".allowed_target_projects_on_move" do

935

context ".allowed_target_projects_on_move" do

936

should "return all active projects for admin users" do

936

should "return all active projects for admin users" do

937

User.current = User.find(1)

937

User.current = User.find(1)

938

assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size

938

assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size

939

end

939

end

940

941

should "return allowed projects for non admin users" do

941

should "return allowed projects for non admin users" do

942

User.current = User.find(2)

942

User.current = User.find(2)

943

Role.non_member.remove_permission! :move_issues

943

Role.non_member.remove_permission! :move_issues

944

assert_equal 3, Issue.allowed_target_projects_on_move.size

944

assert_equal 3, Issue.allowed_target_projects_on_move.size

945

946

Role.non_member.add_permission! :move_issues

946

Role.non_member.add_permission! :move_issues

947

assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size

947

assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size

948

end

948

end

949

end

949

end

950

951

def test_recently_updated_with_limit_scopes

951

def test_recently_updated_with_limit_scopes

952

#should return the last updated issue

952

#should return the last updated issue

953

assert_equal 1, Issue.recently_updated.with_limit(1).length

953

assert_equal 1, Issue.recently_updated.with_limit(1).length

954

assert_equal Issue.find(:first, :order => "updated_on DESC"), Issue.recently_updated.with_limit(1).first

954

assert_equal Issue.find(:first, :order => "updated_on DESC"), Issue.recently_updated.with_limit(1).first

955

end

955

end

956

957

def test_on_active_projects_scope

957

def test_on_active_projects_scope

958

assert Project.find(2).archive

958

assert Project.find(2).archive

959

960

before = Issue.on_active_project.length

960

before = Issue.on_active_project.length

961

# test inclusion to results

961

# test inclusion to results

962

issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first)

962

issue = Issue.generate_for_project!(Project.find(1), :tracker => Project.find(2).trackers.first)

963

assert_equal before + 1, Issue.on_active_project.length

963

assert_equal before + 1, Issue.on_active_project.length

964

965

# Move to an archived project

965

# Move to an archived project

966

issue.project = Project.find(2)

966

issue.project = Project.find(2)

967

assert issue.save

967

assert issue.save

968

assert_equal before, Issue.on_active_project.length

968

assert_equal before, Issue.on_active_project.length

969

end

969

end

970

971

context "Issue#recipients" do

971

context "Issue#recipients" do

972

setup do

972

setup do

973

@project = Project.find(1)

973

@project = Project.find(1)

974

@author = User.generate_with_protected!

974

@author = User.generate_with_protected!

975

@assignee = User.generate_with_protected!

975

@assignee = User.generate_with_protected!

976

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

976

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

977

end

977

end

978

979

should "include project recipients" do

979

should "include project recipients" do

980

assert @project.recipients.present?

980

assert @project.recipients.present?

981

@project.recipients.each do |project_recipient|

981

@project.recipients.each do |project_recipient|

982

assert @issue.recipients.include?(project_recipient)

982

assert @issue.recipients.include?(project_recipient)

983

end

983

end

984

end

984

end

985

986

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

986

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

987

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

987

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

988

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

988

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

989

end

989

end

990

991

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

991

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

992

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

992

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

993

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

993

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

994

end

994

end

995

996

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

996

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

997

@author.update_attribute(:mail_notification, :none)

997

@author.update_attribute(:mail_notification, :none)

998

999

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

999

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

1000

end

1000

end

1001

1002

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

1002

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

1003

@author.update_attribute(:mail_notification, :only_assigned)

1003

@author.update_attribute(:mail_notification, :only_assigned)

1004

1005

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

1005

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

1006

end

1006

end

1007

1008

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

1008

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

1009

@assignee.update_attribute(:mail_notification, :only_owner)

1009

@assignee.update_attribute(:mail_notification, :only_owner)

1010

1011

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

1011

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

1012

end

1012

end

1013

1014

end

1014

end

1015

end

1015

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-2011  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,
                        :trackers, :projects_trackers,
                        :enabled_modules,
                        :versions,
                        :issue_statuses, :issue_categories, :issue_relations, :workflows,
                        :enumerations,
                        :issues,
                        :custom_fields, :custom_fields_projects, :custom_fields_trackers, :custom_values,
                        :time_entries
               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?
               end
               def test_create_with_required_custom_field
                 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 I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                 # Blank value
                 issue.custom_field_values = { field.id => '' }
                 assert !issue.save
                 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                 # Invalid value
                 issue.custom_field_values = { field.id => 'SQLServer' }
                 assert !issue.save
                 assert_equal I18n.translate('activerecord.errors.messages.invalid'), issue.errors.on(:custom_values)
                 # 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 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_with_own_issues_visibility
                 Role.anonymous.update_attribute :issues_visibility, 'own'
                 Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => User.anonymous.id, :subject => 'Issue by anonymous')
                 issues = Issue.visible(User.anonymous).all
                 assert issues.any?
                 assert_nil issues.detect {|issue| issue.author != User.anonymous}
                 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_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_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_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_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_tracker_id_first
                 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_not_nil issue.custom_value_for(1)
                 assert_equal 'MySQL', issue.custom_value_for(1).value
               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.on(: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
                 Workflow.delete_all
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 2, :author => false, :assignee => false)
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3, :author => true, :assignee => false)
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4, :author => false, :assignee => true)
                 Workflow.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)
                 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], issue.new_statuses_allowed_to(user).map(&:id)
+                assert_equal [1, 2, 3, 5], issue.new_statuses_allowed_to(user).map(&:id)
                 issue = Issue.generate!(:tracker => tracker, :status => status, :project_id => 1, :assigned_to => user)
-                assert_equal [1, 2, 4], issue.new_statuses_allowed_to(user).map(&:id)
+                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_copy
                 issue = Issue.new.copy_from(1)
                 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_should_close_duplicates
                 # Create 3 issues
                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                 assert issue1.save
                 issue2 = issue1.clone
                 assert issue2.save
                 issue3 = issue1.clone
                 assert issue3.save
                 # 2 is a dupe of 1
                 IssueRelation.create(:issue_from => issue2, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 2
                 IssueRelation.create(:issue_from => issue3, :issue_to => issue2, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 # And 3 is a dupe of 1 (circular duplicates)
                 IssueRelation.create(:issue_from => issue3, :issue_to => issue1, :relation_type => IssueRelation::TYPE_DUPLICATES)
                 assert issue1.reload.duplicates.include?(issue2)
                 # Closing issue 1
                 issue1.init_journal(User.find(:first), "Closing issue1")
                 issue1.status = IssueStatus.find :first, :conditions => {:is_closed => true}
                 assert issue1.save
                 # 2 and 3 should be also closed
                 assert issue2.reload.closed?
                 assert issue3.reload.closed?
               end
               def test_should_not_close_duplicated_issue
                 # Create 3 issues
                 issue1 = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 1, :status_id => 1, :priority => IssuePriority.all.first, :subject => 'Duplicates test', :description => 'Duplicates test')
                 assert issue1.save
                 issue2 = issue1.clone
                 assert issue2.save
                 # 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.on(: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.on(: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.on_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_move_to_another_project_with_same_category
                 issue = Issue.find(1)
                 assert issue.move_to_project(Project.find(2))
                 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)
                 assert issue.move_to_project(Project.find(2))
                 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)
                 assert issue.move_to_project(Project.find(2))
                 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)
                 assert issue.move_to_project(Project.find(5))
                 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)
                 assert issue.move_to_project(Project.find(5))
                 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)
                 assert issue.move_to_project(Project.find(2))
                 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_with_disabled_tracker
                 issue = Issue.find(1)
                 target = Project.find(2)
                 target.tracker_ids = [3]
                 target.save
                 assert_equal false, issue.move_to_project(target)
                 issue.reload
                 assert_equal 1, issue.project_id
               end
               def test_copy_to_the_same_project
                 issue = Issue.find(1)
                 copy = nil
                 assert_difference 'Issue.count' do
                   copy = issue.move_to_project(issue.project, nil, :copy => true)
                 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 = nil
                 assert_difference 'Issue.count' do
                   copy = issue.move_to_project(Project.find(3), Tracker.find(2), :copy => true)
                 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 "#move_to_project" do
                 context "as a copy" do
                   setup do
                     @issue = Issue.find(1)
                     @copy = nil
                   end
                   should "not create a journal" do
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
                     assert_equal 0, @copy.reload.journals.size
                   end
                   should "allow assigned_to changes" do
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:assigned_to_id => 3}})
                     assert_equal 3, @copy.assigned_to_id
                   end
                   should "allow status changes" do
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:status_id => 2}})
                     assert_equal 2, @copy.status_id
                   end
                   should "allow start date changes" do
                     date = Date.today
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})
                     assert_equal date, @copy.start_date
                   end
                   should "allow due date changes" do
                     date = Date.today
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:due_date => date}})
                     assert_equal date, @copy.due_date
                   end
                   should "set current user as author" do
                     User.current = User.find(9)
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {}})
                     assert_equal User.current, @copy.author
                   end
                   should "keep journal notes" do
                     date = Date.today
                     notes = "Notes added when copying"
                     User.current = User.find(9)
                     @issue.init_journal(User.current, notes)
                     @copy = @issue.move_to_project(Project.find(3), Tracker.find(2), {:copy => true, :attributes => {:start_date => date}})
                     assert_equal 1, @copy.journals.size
                     journal = @copy.journals.first
                     assert_equal 0, journal.details.size
                     assert_equal notes, journal.notes
                   end
                 end
               end
               def test_recipients_should_not_include_users_that_cannot_view_the_issue
                 issue = Issue.find(12)
                 assert issue.recipients.include?(issue.author.mail)
                 # move the issue to a private project
                 copy  = issue.move_to_project(Project.find(5), Tracker.find(2), :copy => true)
                 # author is not a member of project anymore
                 assert !copy.recipients.include?(copy.author.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_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_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
                   project = Project.find(1)
                   non_project_member = User.generate!
                   issue = Issue.generate_for_project!(project, :author => non_project_member)
                   assert issue.assignable_users.include?(non_project_member)
                 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
               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_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)
                 # Validation skipping
                 assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_PRECEDES).save(false)
                 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)
                 # Validation skipping
                 assert IssueRelation.new(:issue_from => Issue.find(8), :issue_to => Issue.find(2), :relation_type => IssueRelation::TYPE_RELATES).save(false)
                 assert IssueRelation.new(:issue_from => Issue.find(3), :issue_to => Issue.find(1), :relation_type => IssueRelation::TYPE_RELATES).save(false)
                 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
                 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
               context ".allowed_target_projects_on_move" do
                 should "return all active projects for admin users" do
                   User.current = User.find(1)
                   assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
                 end
                 should "return allowed projects for non admin users" do
                   User.current = User.find(2)
                   Role.non_member.remove_permission! :move_issues
                   assert_equal 3, Issue.allowed_target_projects_on_move.size
                   Role.non_member.add_permission! :move_issues
                   assert_equal Project.active.count, Issue.allowed_target_projects_on_move.size
                 end
               end
               def test_recently_updated_with_limit_scopes
                 #should return the last updated issue
                 assert_equal 1, Issue.recently_updated.with_limit(1).length
                 assert_equal Issue.find(:first, :order => "updated_on DESC"), Issue.recently_updated.with_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_for_project!(Project.find(1), :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_with_protected!
                   @assignee = User.generate_with_protected!
                   @issue = Issue.generate_for_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
             end