jro_apps/redmine Commit - r8266:4f9f68046cd4

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

20

class ProjectTest < ActiveSupport::TestCase

21

fixtures :projects, :trackers, :issue_statuses, :issues,

21

fixtures :projects, :trackers, :issue_statuses, :issues,

22

:journals, :journal_details,

22

:journals, :journal_details,

23

:enumerations, :users, :issue_categories,

23

:enumerations, :users, :issue_categories,

24

:projects_trackers,

24

:projects_trackers,

25

:custom_fields,

25

:custom_fields,

26

:custom_fields_projects,

26

:custom_fields_projects,

27

:custom_fields_trackers,

27

:custom_fields_trackers,

28

:custom_values,

28

:custom_values,

29

:roles,

29

:roles,

30

:member_roles,

30

:member_roles,

31

:members,

31

:members,

32

:enabled_modules,

32

:enabled_modules,

33

:workflows,

33

:workflows,

34

:versions,

34

:versions,

35

:wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,

35

:wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,

36

:groups_users,

36

:groups_users,

37

:boards,

37

:boards,

38

:repositories

38

:repositories

39

40

def setup

40

def setup

41

@ecookbook = Project.find(1)

41

@ecookbook = Project.find(1)

42

@ecookbook_sub1 = Project.find(3)

42

@ecookbook_sub1 = Project.find(3)

43

set_tmp_attachments_directory

43

set_tmp_attachments_directory

44

User.current = nil

44

User.current = nil

45

end

45

end

46

47

should_validate_presence_of :name

47

should_validate_presence_of :name

48

should_validate_presence_of :identifier

48

should_validate_presence_of :identifier

49

50

should_validate_uniqueness_of :identifier

50

should_validate_uniqueness_of :identifier

51

52

context "associations" do

52

context "associations" do

53

should_have_many :members

53

should_have_many :members

54

should_have_many :users, :through => :members

54

should_have_many :users, :through => :members

55

should_have_many :member_principals

55

should_have_many :member_principals

56

should_have_many :principals, :through => :member_principals

56

should_have_many :principals, :through => :member_principals

57

should_have_many :enabled_modules

57

should_have_many :enabled_modules

58

should_have_many :issues

58

should_have_many :issues

59

should_have_many :issue_changes, :through => :issues

59

should_have_many :issue_changes, :through => :issues

60

should_have_many :versions

60

should_have_many :versions

61

should_have_many :time_entries

61

should_have_many :time_entries

62

should_have_many :queries

62

should_have_many :queries

63

should_have_many :documents

63

should_have_many :documents

64

should_have_many :news

64

should_have_many :news

65

should_have_many :issue_categories

65

should_have_many :issue_categories

66

should_have_many :boards

66

should_have_many :boards

67

should_have_many :changesets, :through => :repository

67

should_have_many :changesets, :through => :repository

68

69

should_have_one :repository

69

should_have_one :repository

70

should_have_one :wiki

70

should_have_one :wiki

71

72

should_have_and_belong_to_many :trackers

72

should_have_and_belong_to_many :trackers

73

should_have_and_belong_to_many :issue_custom_fields

73

should_have_and_belong_to_many :issue_custom_fields

74

end

74

end

75

76

def test_truth

76

def test_truth

77

assert_kind_of Project, @ecookbook

77

assert_kind_of Project, @ecookbook

78

assert_equal "eCookbook", @ecookbook.name

78

assert_equal "eCookbook", @ecookbook.name

79

end

79

end

80

81

def test_default_attributes

81

def test_default_attributes

82

with_settings :default_projects_public => '1' do

82

with_settings :default_projects_public => '1' do

83

assert_equal true, Project.new.is_public

83

assert_equal true, Project.new.is_public

84

assert_equal false, Project.new(:is_public => false).is_public

84

assert_equal false, Project.new(:is_public => false).is_public

85

end

85

end

86

87

with_settings :default_projects_public => '0' do

87

with_settings :default_projects_public => '0' do

88

assert_equal false, Project.new.is_public

88

assert_equal false, Project.new.is_public

89

assert_equal true, Project.new(:is_public => true).is_public

89

assert_equal true, Project.new(:is_public => true).is_public

90

end

90

end

91

92

with_settings :sequential_project_identifiers => '1' do

92

with_settings :sequential_project_identifiers => '1' do

93

assert !Project.new.identifier.blank?

93

assert !Project.new.identifier.blank?

94

assert Project.new(:identifier => '').identifier.blank?

94

assert Project.new(:identifier => '').identifier.blank?

95

end

95

end

96

97

with_settings :sequential_project_identifiers => '0' do

97

with_settings :sequential_project_identifiers => '0' do

98

assert Project.new.identifier.blank?

98

assert Project.new.identifier.blank?

99

assert !Project.new(:identifier => 'test').blank?

99

assert !Project.new(:identifier => 'test').blank?

100

end

100

end

101

102

with_settings :default_projects_modules => ['issue_tracking', 'repository'] do

102

with_settings :default_projects_modules => ['issue_tracking', 'repository'] do

103

assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names

103

assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names

104

end

104

end

105

106

assert_equal Tracker.all, Project.new.trackers

106

assert_equal Tracker.all, Project.new.trackers

107

assert_equal Tracker.find(1, 3), Project.new(:tracker_ids => [1, 3]).trackers

107

assert_equal Tracker.find(1, 3), Project.new(:tracker_ids => [1, 3]).trackers

108

end

108

end

109

110

def test_update

110

def test_update

111

assert_equal "eCookbook", @ecookbook.name

111

assert_equal "eCookbook", @ecookbook.name

112

@ecookbook.name = "eCook"

112

@ecookbook.name = "eCook"

113

assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")

113

assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")

114

@ecookbook.reload

114

@ecookbook.reload

115

assert_equal "eCook", @ecookbook.name

115

assert_equal "eCook", @ecookbook.name

116

end

116

end

117

118

def test_validate_identifier

118

def test_validate_identifier

119

to_test = {"abc" => true,

119

to_test = {"abc" => true,

120

"ab12" => true,

120

"ab12" => true,

121

"ab-12" => true,

121

"ab-12" => true,

122

"12" => false,

122

"12" => false,

123

"new" => false}

123

"new" => false}

124

125

to_test.each do |identifier, valid|

125

to_test.each do |identifier, valid|

126

p = Project.new

126

p = Project.new

127

p.identifier = identifier

127

p.identifier = identifier

128

p.valid?

128

p.valid?

129

assert_equal valid, p.errors['identifier'].nil?

129

if valid

130

assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"

131

else

132

assert p.errors['identifier'].present?, "identifier #{identifier} was valid"

133

end

130

end

134

end

131

end

135

end

132

136

133

def test_members_should_be_active_users

137

def test_members_should_be_active_users

134

Project.all.each do |project|

138

Project.all.each do |project|

135

assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }

139

assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }

136

end

140

end

137

end

141

end

138

142

139

def test_users_should_be_active_users

143

def test_users_should_be_active_users

140

Project.all.each do |project|

144

Project.all.each do |project|

141

assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }

145

assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }

142

end

146

end

143

end

147

end

144

148

145

def test_archive

149

def test_archive

146

user = @ecookbook.members.first.user

150

user = @ecookbook.members.first.user

147

@ecookbook.archive

151

@ecookbook.archive

148

@ecookbook.reload

152

@ecookbook.reload

149

153

150

assert !@ecookbook.active?

154

assert !@ecookbook.active?

151

assert @ecookbook.archived?

155

assert @ecookbook.archived?

152

assert !user.projects.include?(@ecookbook)

156

assert !user.projects.include?(@ecookbook)

153

# Subproject are also archived

157

# Subproject are also archived

154

assert !@ecookbook.children.empty?

158

assert !@ecookbook.children.empty?

155

assert @ecookbook.descendants.active.empty?

159

assert @ecookbook.descendants.active.empty?

156

end

160

end

157

161

158

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

162

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

159

# Assign an issue of a project to a version of a child project

163

# Assign an issue of a project to a version of a child project

160

Issue.find(4).update_attribute :fixed_version_id, 4

164

Issue.find(4).update_attribute :fixed_version_id, 4

161

165

162

assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do

166

assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do

163

assert_equal false, @ecookbook.archive

167

assert_equal false, @ecookbook.archive

164

end

168

end

165

@ecookbook.reload

169

@ecookbook.reload

166

assert @ecookbook.active?

170

assert @ecookbook.active?

167

end

171

end

168

172

169

def test_unarchive

173

def test_unarchive

170

user = @ecookbook.members.first.user

174

user = @ecookbook.members.first.user

171

@ecookbook.archive

175

@ecookbook.archive

172

# A subproject of an archived project can not be unarchived

176

# A subproject of an archived project can not be unarchived

173

assert !@ecookbook_sub1.unarchive

177

assert !@ecookbook_sub1.unarchive

174

178

175

# Unarchive project

179

# Unarchive project

176

assert @ecookbook.unarchive

180

assert @ecookbook.unarchive

177

@ecookbook.reload

181

@ecookbook.reload

178

assert @ecookbook.active?

182

assert @ecookbook.active?

179

assert !@ecookbook.archived?

183

assert !@ecookbook.archived?

180

assert user.projects.include?(@ecookbook)

184

assert user.projects.include?(@ecookbook)

181

# Subproject can now be unarchived

185

# Subproject can now be unarchived

182

@ecookbook_sub1.reload

186

@ecookbook_sub1.reload

183

assert @ecookbook_sub1.unarchive

187

assert @ecookbook_sub1.unarchive

184

end

188

end

185

189

186

def test_destroy

190

def test_destroy

187

# 2 active members

191

# 2 active members

188

assert_equal 2, @ecookbook.members.size

192

assert_equal 2, @ecookbook.members.size

189

# and 1 is locked

193

# and 1 is locked

190

assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size

194

assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size

191

# some boards

195

# some boards

192

assert @ecookbook.boards.any?

196

assert @ecookbook.boards.any?

193

197

194

@ecookbook.destroy

198

@ecookbook.destroy

195

# make sure that the project non longer exists

199

# make sure that the project non longer exists

196

assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }

200

assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }

197

# make sure related data was removed

201

# make sure related data was removed

198

assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})

202

assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})

199

assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})

203

assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})

200

assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})

204

assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})

201

end

205

end

202

206

203

def test_destroying_root_projects_should_clear_data

207

def test_destroying_root_projects_should_clear_data

204

Project.roots.each do |root|

208

Project.roots.each do |root|

205

root.destroy

209

root.destroy

206

end

210

end

207

211

208

assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"

212

assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"

209

assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"

213

assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"

210

assert_equal 0, MemberRole.count

214

assert_equal 0, MemberRole.count

211

assert_equal 0, Issue.count

215

assert_equal 0, Issue.count

212

assert_equal 0, Journal.count

216

assert_equal 0, Journal.count

213

assert_equal 0, JournalDetail.count

217

assert_equal 0, JournalDetail.count

214

assert_equal 0, Attachment.count

218

assert_equal 0, Attachment.count

215

assert_equal 0, EnabledModule.count

219

assert_equal 0, EnabledModule.count

216

assert_equal 0, IssueCategory.count

220

assert_equal 0, IssueCategory.count

217

assert_equal 0, IssueRelation.count

221

assert_equal 0, IssueRelation.count

218

assert_equal 0, Board.count

222

assert_equal 0, Board.count

219

assert_equal 0, Message.count

223

assert_equal 0, Message.count

220

assert_equal 0, News.count

224

assert_equal 0, News.count

221

assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")

225

assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")

222

assert_equal 0, Repository.count

226

assert_equal 0, Repository.count

223

assert_equal 0, Changeset.count

227

assert_equal 0, Changeset.count

224

assert_equal 0, Change.count

228

assert_equal 0, Change.count

225

assert_equal 0, Comment.count

229

assert_equal 0, Comment.count

226

assert_equal 0, TimeEntry.count

230

assert_equal 0, TimeEntry.count

227

assert_equal 0, Version.count

231

assert_equal 0, Version.count

228

assert_equal 0, Watcher.count

232

assert_equal 0, Watcher.count

229

assert_equal 0, Wiki.count

233

assert_equal 0, Wiki.count

230

assert_equal 0, WikiPage.count

234

assert_equal 0, WikiPage.count

231

assert_equal 0, WikiContent.count

235

assert_equal 0, WikiContent.count

232

assert_equal 0, WikiContent::Version.count

236

assert_equal 0, WikiContent::Version.count

233

assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size

237

assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size

234

assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size

238

assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size

235

assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})

239

assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})

236

end

240

end

237

241

238

def test_move_an_orphan_project_to_a_root_project

242

def test_move_an_orphan_project_to_a_root_project

239

sub = Project.find(2)

243

sub = Project.find(2)

240

sub.set_parent! @ecookbook

244

sub.set_parent! @ecookbook

241

assert_equal @ecookbook.id, sub.parent.id

245

assert_equal @ecookbook.id, sub.parent.id

242

@ecookbook.reload

246

@ecookbook.reload

243

assert_equal 4, @ecookbook.children.size

247

assert_equal 4, @ecookbook.children.size

244

end

248

end

245

249

246

def test_move_an_orphan_project_to_a_subproject

250

def test_move_an_orphan_project_to_a_subproject

247

sub = Project.find(2)

251

sub = Project.find(2)

248

assert sub.set_parent!(@ecookbook_sub1)

252

assert sub.set_parent!(@ecookbook_sub1)

249

end

253

end

250

254

251

def test_move_a_root_project_to_a_project

255

def test_move_a_root_project_to_a_project

252

sub = @ecookbook

256

sub = @ecookbook

253

assert sub.set_parent!(Project.find(2))

257

assert sub.set_parent!(Project.find(2))

254

end

258

end

255

259

256

def test_should_not_move_a_project_to_its_children

260

def test_should_not_move_a_project_to_its_children

257

sub = @ecookbook

261

sub = @ecookbook

258

assert !(sub.set_parent!(Project.find(3)))

262

assert !(sub.set_parent!(Project.find(3)))

259

end

263

end

260

264

261

def test_set_parent_should_add_roots_in_alphabetical_order

265

def test_set_parent_should_add_roots_in_alphabetical_order

262

ProjectCustomField.delete_all

266

ProjectCustomField.delete_all

263

Project.delete_all

267

Project.delete_all

264

Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)

268

Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)

265

Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)

269

Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)

266

Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)

270

Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)

267

Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)

271

Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)

268

272

269

assert_equal 4, Project.count

273

assert_equal 4, Project.count

270

assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)

274

assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)

271

end

275

end

272

276

273

def test_set_parent_should_add_children_in_alphabetical_order

277

def test_set_parent_should_add_children_in_alphabetical_order

274

ProjectCustomField.delete_all

278

ProjectCustomField.delete_all

275

parent = Project.create!(:name => 'Parent', :identifier => 'parent')

279

parent = Project.create!(:name => 'Parent', :identifier => 'parent')

276

Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)

280

Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)

277

Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)

281

Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)

278

Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)

282

Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)

279

Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)

283

Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)

280

284

281

parent.reload

285

parent.reload

282

assert_equal 4, parent.children.size

286

assert_equal 4, parent.children.size

283

assert_equal parent.children.all.sort_by(&:name), parent.children.all

287

assert_equal parent.children.all.sort_by(&:name), parent.children.all

284

end

288

end

285

289

286

def test_rebuild_should_sort_children_alphabetically

290

def test_rebuild_should_sort_children_alphabetically

287

ProjectCustomField.delete_all

291

ProjectCustomField.delete_all

288

parent = Project.create!(:name => 'Parent', :identifier => 'parent')

292

parent = Project.create!(:name => 'Parent', :identifier => 'parent')

289

Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)

293

Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)

290

Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)

294

Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)

291

Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)

295

Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)

292

Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)

296

Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)

293

297

294

Project.update_all("lft = NULL, rgt = NULL")

298

Project.update_all("lft = NULL, rgt = NULL")

295

Project.rebuild!

299

Project.rebuild!

296

300

297

parent.reload

301

parent.reload

298

assert_equal 4, parent.children.size

302

assert_equal 4, parent.children.size

299

assert_equal parent.children.all.sort_by(&:name), parent.children.all

303

assert_equal parent.children.all.sort_by(&:name), parent.children.all

300

end

304

end

301

305

302

306

303

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

307

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

304

# Parent issue with a hierarchy project's fixed version

308

# Parent issue with a hierarchy project's fixed version

305

parent_issue = Issue.find(1)

309

parent_issue = Issue.find(1)

306

parent_issue.update_attribute(:fixed_version_id, 4)

310

parent_issue.update_attribute(:fixed_version_id, 4)

307

parent_issue.reload

311

parent_issue.reload

308

assert_equal 4, parent_issue.fixed_version_id

312

assert_equal 4, parent_issue.fixed_version_id

309

313

310

# Should keep fixed versions for the issues

314

# Should keep fixed versions for the issues

311

issue_with_local_fixed_version = Issue.find(5)

315

issue_with_local_fixed_version = Issue.find(5)

312

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

316

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

313

issue_with_local_fixed_version.reload

317

issue_with_local_fixed_version.reload

314

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

318

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

315

319

316

# Local issue with hierarchy fixed_version

320

# Local issue with hierarchy fixed_version

317

issue_with_hierarchy_fixed_version = Issue.find(13)

321

issue_with_hierarchy_fixed_version = Issue.find(13)

318

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

322

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

319

issue_with_hierarchy_fixed_version.reload

323

issue_with_hierarchy_fixed_version.reload

320

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

324

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

321

325

322

# Move project out of the issue's hierarchy

326

# Move project out of the issue's hierarchy

323

moved_project = Project.find(3)

327

moved_project = Project.find(3)

324

moved_project.set_parent!(Project.find(2))

328

moved_project.set_parent!(Project.find(2))

325

parent_issue.reload

329

parent_issue.reload

326

issue_with_local_fixed_version.reload

330

issue_with_local_fixed_version.reload

327

issue_with_hierarchy_fixed_version.reload

331

issue_with_hierarchy_fixed_version.reload

328

332

329

assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"

333

assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"

330

assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"

334

assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"

331

assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."

335

assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."

332

end

336

end

333

337

334

def test_parent

338

def test_parent

335

p = Project.find(6).parent

339

p = Project.find(6).parent

336

assert p.is_a?(Project)

340

assert p.is_a?(Project)

337

assert_equal 5, p.id

341

assert_equal 5, p.id

338

end

342

end

339

343

340

def test_ancestors

344

def test_ancestors

341

a = Project.find(6).ancestors

345

a = Project.find(6).ancestors

342

assert a.first.is_a?(Project)

346

assert a.first.is_a?(Project)

343

assert_equal [1, 5], a.collect(&:id)

347

assert_equal [1, 5], a.collect(&:id)

344

end

348

end

345

349

346

def test_root

350

def test_root

347

r = Project.find(6).root

351

r = Project.find(6).root

348

assert r.is_a?(Project)

352

assert r.is_a?(Project)

349

assert_equal 1, r.id

353

assert_equal 1, r.id

350

end

354

end

351

355

352

def test_children

356

def test_children

353

c = Project.find(1).children

357

c = Project.find(1).children

354

assert c.first.is_a?(Project)

358

assert c.first.is_a?(Project)

355

assert_equal [5, 3, 4], c.collect(&:id)

359

assert_equal [5, 3, 4], c.collect(&:id)

356

end

360

end

357

361

358

def test_descendants

362

def test_descendants

359

d = Project.find(1).descendants

363

d = Project.find(1).descendants

360

assert d.first.is_a?(Project)

364

assert d.first.is_a?(Project)

361

assert_equal [5, 6, 3, 4], d.collect(&:id)

365

assert_equal [5, 6, 3, 4], d.collect(&:id)

362

end

366

end

363

367

364

def test_allowed_parents_should_be_empty_for_non_member_user

368

def test_allowed_parents_should_be_empty_for_non_member_user

365

Role.non_member.add_permission!(:add_project)

369

Role.non_member.add_permission!(:add_project)

366

user = User.find(9)

370

user = User.find(9)

367

assert user.memberships.empty?

371

assert user.memberships.empty?

368

User.current = user

372

User.current = user

369

assert Project.new.allowed_parents.compact.empty?

373

assert Project.new.allowed_parents.compact.empty?

370

end

374

end

371

375

372

def test_allowed_parents_with_add_subprojects_permission

376

def test_allowed_parents_with_add_subprojects_permission

373

Role.find(1).remove_permission!(:add_project)

377

Role.find(1).remove_permission!(:add_project)

374

Role.find(1).add_permission!(:add_subprojects)

378

Role.find(1).add_permission!(:add_subprojects)

375

User.current = User.find(2)

379

User.current = User.find(2)

376

# new project

380

# new project

377

assert !Project.new.allowed_parents.include?(nil)

381

assert !Project.new.allowed_parents.include?(nil)

378

assert Project.new.allowed_parents.include?(Project.find(1))

382

assert Project.new.allowed_parents.include?(Project.find(1))

379

# existing root project

383

# existing root project

380

assert Project.find(1).allowed_parents.include?(nil)

384

assert Project.find(1).allowed_parents.include?(nil)

381

# existing child

385

# existing child

382

assert Project.find(3).allowed_parents.include?(Project.find(1))

386

assert Project.find(3).allowed_parents.include?(Project.find(1))

383

assert !Project.find(3).allowed_parents.include?(nil)

387

assert !Project.find(3).allowed_parents.include?(nil)

384

end

388

end

385

389

386

def test_allowed_parents_with_add_project_permission

390

def test_allowed_parents_with_add_project_permission

387

Role.find(1).add_permission!(:add_project)

391

Role.find(1).add_permission!(:add_project)

388

Role.find(1).remove_permission!(:add_subprojects)

392

Role.find(1).remove_permission!(:add_subprojects)

389

User.current = User.find(2)

393

User.current = User.find(2)

390

# new project

394

# new project

391

assert Project.new.allowed_parents.include?(nil)

395

assert Project.new.allowed_parents.include?(nil)

392

assert !Project.new.allowed_parents.include?(Project.find(1))

396

assert !Project.new.allowed_parents.include?(Project.find(1))

393

# existing root project

397

# existing root project

394

assert Project.find(1).allowed_parents.include?(nil)

398

assert Project.find(1).allowed_parents.include?(nil)

395

# existing child

399

# existing child

396

assert Project.find(3).allowed_parents.include?(Project.find(1))

400

assert Project.find(3).allowed_parents.include?(Project.find(1))

397

assert Project.find(3).allowed_parents.include?(nil)

401

assert Project.find(3).allowed_parents.include?(nil)

398

end

402

end

399

403

400

def test_allowed_parents_with_add_project_and_subprojects_permission

404

def test_allowed_parents_with_add_project_and_subprojects_permission

401

Role.find(1).add_permission!(:add_project)

405

Role.find(1).add_permission!(:add_project)

402

Role.find(1).add_permission!(:add_subprojects)

406

Role.find(1).add_permission!(:add_subprojects)

403

User.current = User.find(2)

407

User.current = User.find(2)

404

# new project

408

# new project

405

assert Project.new.allowed_parents.include?(nil)

409

assert Project.new.allowed_parents.include?(nil)

406

assert Project.new.allowed_parents.include?(Project.find(1))

410

assert Project.new.allowed_parents.include?(Project.find(1))

407

# existing root project

411

# existing root project

408

assert Project.find(1).allowed_parents.include?(nil)

412

assert Project.find(1).allowed_parents.include?(nil)

409

# existing child

413

# existing child

410

assert Project.find(3).allowed_parents.include?(Project.find(1))

414

assert Project.find(3).allowed_parents.include?(Project.find(1))

411

assert Project.find(3).allowed_parents.include?(nil)

415

assert Project.find(3).allowed_parents.include?(nil)

412

end

416

end

413

417

414

def test_users_by_role

418

def test_users_by_role

415

users_by_role = Project.find(1).users_by_role

419

users_by_role = Project.find(1).users_by_role

416

assert_kind_of Hash, users_by_role

420

assert_kind_of Hash, users_by_role

417

role = Role.find(1)

421

role = Role.find(1)

418

assert_kind_of Array, users_by_role[role]

422

assert_kind_of Array, users_by_role[role]

419

assert users_by_role[role].include?(User.find(2))

423

assert users_by_role[role].include?(User.find(2))

420

end

424

end

421

425

422

def test_rolled_up_trackers

426

def test_rolled_up_trackers

423

parent = Project.find(1)

427

parent = Project.find(1)

424

parent.trackers = Tracker.find([1,2])

428

parent.trackers = Tracker.find([1,2])

425

child = parent.children.find(3)

429

child = parent.children.find(3)

426

430

427

assert_equal [1, 2], parent.tracker_ids

431

assert_equal [1, 2], parent.tracker_ids

428

assert_equal [2, 3], child.trackers.collect(&:id)

432

assert_equal [2, 3], child.trackers.collect(&:id)

429

433

430

assert_kind_of Tracker, parent.rolled_up_trackers.first

434

assert_kind_of Tracker, parent.rolled_up_trackers.first

431

assert_equal Tracker.find(1), parent.rolled_up_trackers.first

435

assert_equal Tracker.find(1), parent.rolled_up_trackers.first

432

436

433

assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)

437

assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)

434

assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)

438

assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)

435

end

439

end

436

440

437

def test_rolled_up_trackers_should_ignore_archived_subprojects

441

def test_rolled_up_trackers_should_ignore_archived_subprojects

438

parent = Project.find(1)

442

parent = Project.find(1)

439

parent.trackers = Tracker.find([1,2])

443

parent.trackers = Tracker.find([1,2])

440

child = parent.children.find(3)

444

child = parent.children.find(3)

441

child.trackers = Tracker.find([1,3])

445

child.trackers = Tracker.find([1,3])

442

parent.children.each(&:archive)

446

parent.children.each(&:archive)

443

447

444

assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)

448

assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)

445

end

449

end

446

450

447

context "#rolled_up_versions" do

451

context "#rolled_up_versions" do

448

setup do

452

setup do

449

@project = Project.generate!

453

@project = Project.generate!

450

@parent_version_1 = Version.generate!(:project => @project)

454

@parent_version_1 = Version.generate!(:project => @project)

451

@parent_version_2 = Version.generate!(:project => @project)

455

@parent_version_2 = Version.generate!(:project => @project)

452

end

456

end

453

457

454

should "include the versions for the current project" do

458

should "include the versions for the current project" do

455

assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions

459

assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions

456

end

460

end

457

461

458

should "include versions for a subproject" do

462

should "include versions for a subproject" do

459

@subproject = Project.generate!

463

@subproject = Project.generate!

460

@subproject.set_parent!(@project)

464

@subproject.set_parent!(@project)

461

@subproject_version = Version.generate!(:project => @subproject)

465

@subproject_version = Version.generate!(:project => @subproject)

462

466

463

assert_same_elements [

467

assert_same_elements [

464

@parent_version_1,

468

@parent_version_1,

465

@parent_version_2,

469

@parent_version_2,

466

@subproject_version

470

@subproject_version

467

], @project.rolled_up_versions

471

], @project.rolled_up_versions

468

end

472

end

469

473

470

should "include versions for a sub-subproject" do

474

should "include versions for a sub-subproject" do

471

@subproject = Project.generate!

475

@subproject = Project.generate!

472

@subproject.set_parent!(@project)

476

@subproject.set_parent!(@project)

473

@sub_subproject = Project.generate!

477

@sub_subproject = Project.generate!

474

@sub_subproject.set_parent!(@subproject)

478

@sub_subproject.set_parent!(@subproject)

475

@sub_subproject_version = Version.generate!(:project => @sub_subproject)

479

@sub_subproject_version = Version.generate!(:project => @sub_subproject)

476

480

477

@project.reload

481

@project.reload

478

482

479

assert_same_elements [

483

assert_same_elements [

480

@parent_version_1,

484

@parent_version_1,

481

@parent_version_2,

485

@parent_version_2,

482

@sub_subproject_version

486

@sub_subproject_version

483

], @project.rolled_up_versions

487

], @project.rolled_up_versions

484

end

488

end

485

489

486

should "only check active projects" do

490

should "only check active projects" do

487

@subproject = Project.generate!

491

@subproject = Project.generate!

488

@subproject.set_parent!(@project)

492

@subproject.set_parent!(@project)

489

@subproject_version = Version.generate!(:project => @subproject)

493

@subproject_version = Version.generate!(:project => @subproject)

490

assert @subproject.archive

494

assert @subproject.archive

491

495

492

@project.reload

496

@project.reload

493

497

494

assert !@subproject.active?

498

assert !@subproject.active?

495

assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions

499

assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions

496

end

500

end

497

end

501

end

498

502

499

def test_shared_versions_none_sharing

503

def test_shared_versions_none_sharing

500

p = Project.find(5)

504

p = Project.find(5)

501

v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')

505

v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')

502

assert p.shared_versions.include?(v)

506

assert p.shared_versions.include?(v)

503

assert !p.children.first.shared_versions.include?(v)

507

assert !p.children.first.shared_versions.include?(v)

504

assert !p.root.shared_versions.include?(v)

508

assert !p.root.shared_versions.include?(v)

505

assert !p.siblings.first.shared_versions.include?(v)

509

assert !p.siblings.first.shared_versions.include?(v)

506

assert !p.root.siblings.first.shared_versions.include?(v)

510

assert !p.root.siblings.first.shared_versions.include?(v)

507

end

511

end

508

512

509

def test_shared_versions_descendants_sharing

513

def test_shared_versions_descendants_sharing

510

p = Project.find(5)

514

p = Project.find(5)

511

v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')

515

v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')

512

assert p.shared_versions.include?(v)

516

assert p.shared_versions.include?(v)

513

assert p.children.first.shared_versions.include?(v)

517

assert p.children.first.shared_versions.include?(v)

514

assert !p.root.shared_versions.include?(v)

518

assert !p.root.shared_versions.include?(v)

515

assert !p.siblings.first.shared_versions.include?(v)

519

assert !p.siblings.first.shared_versions.include?(v)

516

assert !p.root.siblings.first.shared_versions.include?(v)

520

assert !p.root.siblings.first.shared_versions.include?(v)

517

end

521

end

518

522

519

def test_shared_versions_hierarchy_sharing

523

def test_shared_versions_hierarchy_sharing

520

p = Project.find(5)

524

p = Project.find(5)

521

v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')

525

v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')

522

assert p.shared_versions.include?(v)

526

assert p.shared_versions.include?(v)

523

assert p.children.first.shared_versions.include?(v)

527

assert p.children.first.shared_versions.include?(v)

524

assert p.root.shared_versions.include?(v)

528

assert p.root.shared_versions.include?(v)

525

assert !p.siblings.first.shared_versions.include?(v)

529

assert !p.siblings.first.shared_versions.include?(v)

526

assert !p.root.siblings.first.shared_versions.include?(v)

530

assert !p.root.siblings.first.shared_versions.include?(v)

527

end

531

end

528

532

529

def test_shared_versions_tree_sharing

533

def test_shared_versions_tree_sharing

530

p = Project.find(5)

534

p = Project.find(5)

531

v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')

535

v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')

532

assert p.shared_versions.include?(v)

536

assert p.shared_versions.include?(v)

533

assert p.children.first.shared_versions.include?(v)

537

assert p.children.first.shared_versions.include?(v)

534

assert p.root.shared_versions.include?(v)

538

assert p.root.shared_versions.include?(v)

535

assert p.siblings.first.shared_versions.include?(v)

539

assert p.siblings.first.shared_versions.include?(v)

536

assert !p.root.siblings.first.shared_versions.include?(v)

540

assert !p.root.siblings.first.shared_versions.include?(v)

537

end

541

end

538

542

539

def test_shared_versions_system_sharing

543

def test_shared_versions_system_sharing

540

p = Project.find(5)

544

p = Project.find(5)

541

v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')

545

v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')

542

assert p.shared_versions.include?(v)

546

assert p.shared_versions.include?(v)

543

assert p.children.first.shared_versions.include?(v)

547

assert p.children.first.shared_versions.include?(v)

544

assert p.root.shared_versions.include?(v)

548

assert p.root.shared_versions.include?(v)

545

assert p.siblings.first.shared_versions.include?(v)

549

assert p.siblings.first.shared_versions.include?(v)

546

assert p.root.siblings.first.shared_versions.include?(v)

550

assert p.root.siblings.first.shared_versions.include?(v)

547

end

551

end

548

552

549

def test_shared_versions

553

def test_shared_versions

550

parent = Project.find(1)

554

parent = Project.find(1)

551

child = parent.children.find(3)

555

child = parent.children.find(3)

552

private_child = parent.children.find(5)

556

private_child = parent.children.find(5)

553

557

554

assert_equal [1,2,3], parent.version_ids.sort

558

assert_equal [1,2,3], parent.version_ids.sort

555

assert_equal [4], child.version_ids

559

assert_equal [4], child.version_ids

556

assert_equal [6], private_child.version_ids

560

assert_equal [6], private_child.version_ids

557

assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)

561

assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)

558

562

559

assert_equal 6, parent.shared_versions.size

563

assert_equal 6, parent.shared_versions.size

560

parent.shared_versions.each do |version|

564

parent.shared_versions.each do |version|

561

assert_kind_of Version, version

565

assert_kind_of Version, version

562

end

566

end

563

567

564

assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort

568

assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort

565

end

569

end

566

570

567

def test_shared_versions_should_ignore_archived_subprojects

571

def test_shared_versions_should_ignore_archived_subprojects

568

parent = Project.find(1)

572

parent = Project.find(1)

569

child = parent.children.find(3)

573

child = parent.children.find(3)

570

child.archive

574

child.archive

571

parent.reload

575

parent.reload

572

576

573

assert_equal [1,2,3], parent.version_ids.sort

577

assert_equal [1,2,3], parent.version_ids.sort

574

assert_equal [4], child.version_ids

578

assert_equal [4], child.version_ids

575

assert !parent.shared_versions.collect(&:id).include?(4)

579

assert !parent.shared_versions.collect(&:id).include?(4)

576

end

580

end

577

581

578

def test_shared_versions_visible_to_user

582

def test_shared_versions_visible_to_user

579

user = User.find(3)

583

user = User.find(3)

580

parent = Project.find(1)

584

parent = Project.find(1)

581

child = parent.children.find(5)

585

child = parent.children.find(5)

582

586

583

assert_equal [1,2,3], parent.version_ids.sort

587

assert_equal [1,2,3], parent.version_ids.sort

584

assert_equal [6], child.version_ids

588

assert_equal [6], child.version_ids

585

589

586

versions = parent.shared_versions.visible(user)

590

versions = parent.shared_versions.visible(user)

587

591

588

assert_equal 4, versions.size

592

assert_equal 4, versions.size

589

versions.each do |version|

593

versions.each do |version|

590

assert_kind_of Version, version

594

assert_kind_of Version, version

591

end

595

end

592

596

593

assert !versions.collect(&:id).include?(6)

597

assert !versions.collect(&:id).include?(6)

594

end

598

end

595

599

596

def test_next_identifier

600

def test_next_identifier

597

ProjectCustomField.delete_all

601

ProjectCustomField.delete_all

598

Project.create!(:name => 'last', :identifier => 'p2008040')

602

Project.create!(:name => 'last', :identifier => 'p2008040')

599

assert_equal 'p2008041', Project.next_identifier

603

assert_equal 'p2008041', Project.next_identifier

600

end

604

end

601

605

602

def test_next_identifier_first_project

606

def test_next_identifier_first_project

603

Project.delete_all

607

Project.delete_all

604

assert_nil Project.next_identifier

608

assert_nil Project.next_identifier

605

end

609

end

606

610

607

def test_enabled_module_names

611

def test_enabled_module_names

608

with_settings :default_projects_modules => ['issue_tracking', 'repository'] do

612

with_settings :default_projects_modules => ['issue_tracking', 'repository'] do

609

project = Project.new

613

project = Project.new

610

614

611

project.enabled_module_names = %w(issue_tracking news)

615

project.enabled_module_names = %w(issue_tracking news)

612

assert_equal %w(issue_tracking news), project.enabled_module_names.sort

616

assert_equal %w(issue_tracking news), project.enabled_module_names.sort

613

end

617

end

614

end

618

end

615

619

616

context "enabled_modules" do

620

context "enabled_modules" do

617

setup do

621

setup do

618

@project = Project.find(1)

622

@project = Project.find(1)

619

end

623

end

620

624

621

should "define module by names and preserve ids" do

625

should "define module by names and preserve ids" do

622

# Remove one module

626

# Remove one module

623

modules = @project.enabled_modules.slice(0..-2)

627

modules = @project.enabled_modules.slice(0..-2)

624

assert modules.any?

628

assert modules.any?

625

assert_difference 'EnabledModule.count', -1 do

629

assert_difference 'EnabledModule.count', -1 do

626

@project.enabled_module_names = modules.collect(&:name)

630

@project.enabled_module_names = modules.collect(&:name)

627

end

631

end

628

@project.reload

632

@project.reload

629

# Ids should be preserved

633

# Ids should be preserved

630

assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort

634

assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort

631

end

635

end

632

636

633

should "enable a module" do

637

should "enable a module" do

634

@project.enabled_module_names = []

638

@project.enabled_module_names = []

635

@project.reload

639

@project.reload

636

assert_equal [], @project.enabled_module_names

640

assert_equal [], @project.enabled_module_names

637

#with string

641

#with string

638

@project.enable_module!("issue_tracking")

642

@project.enable_module!("issue_tracking")

639

assert_equal ["issue_tracking"], @project.enabled_module_names

643

assert_equal ["issue_tracking"], @project.enabled_module_names

640

#with symbol

644

#with symbol

641

@project.enable_module!(:gantt)

645

@project.enable_module!(:gantt)

642

assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names

646

assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names

643

#don't add a module twice

647

#don't add a module twice

644

@project.enable_module!("issue_tracking")

648

@project.enable_module!("issue_tracking")

645

assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names

649

assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names

646

end

650

end

647

651

648

should "disable a module" do

652

should "disable a module" do

649

#with string

653

#with string

650

assert @project.enabled_module_names.include?("issue_tracking")

654

assert @project.enabled_module_names.include?("issue_tracking")

651

@project.disable_module!("issue_tracking")

655

@project.disable_module!("issue_tracking")

652

assert ! @project.reload.enabled_module_names.include?("issue_tracking")

656

assert ! @project.reload.enabled_module_names.include?("issue_tracking")

653

#with symbol

657

#with symbol

654

assert @project.enabled_module_names.include?("gantt")

658

assert @project.enabled_module_names.include?("gantt")

655

@project.disable_module!(:gantt)

659

@project.disable_module!(:gantt)

656

assert ! @project.reload.enabled_module_names.include?("gantt")

660

assert ! @project.reload.enabled_module_names.include?("gantt")

657

#with EnabledModule object

661

#with EnabledModule object

658

first_module = @project.enabled_modules.first

662

first_module = @project.enabled_modules.first

659

@project.disable_module!(first_module)

663

@project.disable_module!(first_module)

660

assert ! @project.reload.enabled_module_names.include?(first_module.name)

664

assert ! @project.reload.enabled_module_names.include?(first_module.name)

661

end

665

end

662

end

666

end

663

667

664

def test_enabled_module_names_should_not_recreate_enabled_modules

668

def test_enabled_module_names_should_not_recreate_enabled_modules

665

project = Project.find(1)

669

project = Project.find(1)

666

# Remove one module

670

# Remove one module

667

modules = project.enabled_modules.slice(0..-2)

671

modules = project.enabled_modules.slice(0..-2)

668

assert modules.any?

672

assert modules.any?

669

assert_difference 'EnabledModule.count', -1 do

673

assert_difference 'EnabledModule.count', -1 do

670

project.enabled_module_names = modules.collect(&:name)

674

project.enabled_module_names = modules.collect(&:name)

671

end

675

end

672

project.reload

676

project.reload

673

# Ids should be preserved

677

# Ids should be preserved

674

assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort

678

assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort

675

end

679

end

676

680

677

def test_copy_from_existing_project

681

def test_copy_from_existing_project

678

source_project = Project.find(1)

682

source_project = Project.find(1)

679

copied_project = Project.copy_from(1)

683

copied_project = Project.copy_from(1)

680

684

681

assert copied_project

685

assert copied_project

682

# Cleared attributes

686

# Cleared attributes

683

assert copied_project.id.blank?

687

assert copied_project.id.blank?

684

assert copied_project.name.blank?

688

assert copied_project.name.blank?

685

assert copied_project.identifier.blank?

689

assert copied_project.identifier.blank?

686

690

687

# Duplicated attributes

691

# Duplicated attributes

688

assert_equal source_project.description, copied_project.description

692

assert_equal source_project.description, copied_project.description

689

assert_equal source_project.enabled_modules, copied_project.enabled_modules

693

assert_equal source_project.enabled_modules, copied_project.enabled_modules

690

assert_equal source_project.trackers, copied_project.trackers

694

assert_equal source_project.trackers, copied_project.trackers

691

695

692

# Default attributes

696

# Default attributes

693

assert_equal 1, copied_project.status

697

assert_equal 1, copied_project.status

694

end

698

end

695

699

696

def test_activities_should_use_the_system_activities

700

def test_activities_should_use_the_system_activities

697

project = Project.find(1)

701

project = Project.find(1)

698

assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )

702

assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )

699

end

703

end

700

704

701

705

702

def test_activities_should_use_the_project_specific_activities

706

def test_activities_should_use_the_project_specific_activities

703

project = Project.find(1)

707

project = Project.find(1)

704

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})

708

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})

705

assert overridden_activity.save!

709

assert overridden_activity.save!

706

710

707

assert project.activities.include?(overridden_activity), "Project specific Activity not found"

711

assert project.activities.include?(overridden_activity), "Project specific Activity not found"

708

end

712

end

709

713

710

def test_activities_should_not_include_the_inactive_project_specific_activities

714

def test_activities_should_not_include_the_inactive_project_specific_activities

711

project = Project.find(1)

715

project = Project.find(1)

712

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})

716

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})

713

assert overridden_activity.save!

717

assert overridden_activity.save!

714

718

715

assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"

719

assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"

716

end

720

end

717

721

718

def test_activities_should_not_include_project_specific_activities_from_other_projects

722

def test_activities_should_not_include_project_specific_activities_from_other_projects

719

project = Project.find(1)

723

project = Project.find(1)

720

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})

724

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})

721

assert overridden_activity.save!

725

assert overridden_activity.save!

722

726

723

assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"

727

assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"

724

end

728

end

725

729

726

def test_activities_should_handle_nils

730

def test_activities_should_handle_nils

727

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.find(:first)})

731

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.find(:first)})

728

TimeEntryActivity.delete_all

732

TimeEntryActivity.delete_all

729

733

730

# No activities

734

# No activities

731

project = Project.find(1)

735

project = Project.find(1)

732

assert project.activities.empty?

736

assert project.activities.empty?

733

737

734

# No system, one overridden

738

# No system, one overridden

735

assert overridden_activity.save!

739

assert overridden_activity.save!

736

project.reload

740

project.reload

737

assert_equal [overridden_activity], project.activities

741

assert_equal [overridden_activity], project.activities

738

end

742

end

739

743

740

def test_activities_should_override_system_activities_with_project_activities

744

def test_activities_should_override_system_activities_with_project_activities

741

project = Project.find(1)

745

project = Project.find(1)

742

parent_activity = TimeEntryActivity.find(:first)

746

parent_activity = TimeEntryActivity.find(:first)

743

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})

747

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})

744

assert overridden_activity.save!

748

assert overridden_activity.save!

745

749

746

assert project.activities.include?(overridden_activity), "Project specific Activity not found"

750

assert project.activities.include?(overridden_activity), "Project specific Activity not found"

747

assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"

751

assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"

748

end

752

end

749

753

750

def test_activities_should_include_inactive_activities_if_specified

754

def test_activities_should_include_inactive_activities_if_specified

751

project = Project.find(1)

755

project = Project.find(1)

752

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})

756

overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})

753

assert overridden_activity.save!

757

assert overridden_activity.save!

754

758

755

assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"

759

assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"

756

end

760

end

757

761

758

test 'activities should not include active System activities if the project has an override that is inactive' do

762

test 'activities should not include active System activities if the project has an override that is inactive' do

759

project = Project.find(1)

763

project = Project.find(1)

760

system_activity = TimeEntryActivity.find_by_name('Design')

764

system_activity = TimeEntryActivity.find_by_name('Design')

761

assert system_activity.active?

765

assert system_activity.active?

762

overridden_activity = TimeEntryActivity.generate!(:project => project, :parent => system_activity, :active => false)

766

overridden_activity = TimeEntryActivity.generate!(:project => project, :parent => system_activity, :active => false)

763

assert overridden_activity.save!

767

assert overridden_activity.save!

764

768

765

assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"

769

assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"

766

assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"

770

assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"

767

end

771

end

768

772

769

def test_close_completed_versions

773

def test_close_completed_versions

770

Version.update_all("status = 'open'")

774

Version.update_all("status = 'open'")

771

project = Project.find(1)

775

project = Project.find(1)

772

assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}

776

assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}

773

assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}

777

assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}

774

project.close_completed_versions

778

project.close_completed_versions

775

project.reload

779

project.reload

776

assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}

780

assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}

777

assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}

781

assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}

778

end

782

end

779

783

780

context "Project#copy" do

784

context "Project#copy" do

781

setup do

785

setup do

782

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

786

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

783

Project.destroy_all :identifier => "copy-test"

787

Project.destroy_all :identifier => "copy-test"

784

@source_project = Project.find(2)

788

@source_project = Project.find(2)

785

@project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')

789

@project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')

786

@project.trackers = @source_project.trackers

790

@project.trackers = @source_project.trackers

787

@project.enabled_module_names = @source_project.enabled_modules.collect(&:name)

791

@project.enabled_module_names = @source_project.enabled_modules.collect(&:name)

788

end

792

end

789

793

790

should "copy issues" do

794

should "copy issues" do

791

@source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),

795

@source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),

792

:subject => "copy issue status",

796

:subject => "copy issue status",

793

:tracker_id => 1,

797

:tracker_id => 1,

794

:assigned_to_id => 2,

798

:assigned_to_id => 2,

795

:project_id => @source_project.id)

799

:project_id => @source_project.id)

796

assert @project.valid?

800

assert @project.valid?

797

assert @project.issues.empty?

801

assert @project.issues.empty?

798

assert @project.copy(@source_project)

802

assert @project.copy(@source_project)

799

803

800

assert_equal @source_project.issues.size, @project.issues.size

804

assert_equal @source_project.issues.size, @project.issues.size

801

@project.issues.each do |issue|

805

@project.issues.each do |issue|

802

assert issue.valid?

806

assert issue.valid?

803

assert ! issue.assigned_to.blank?

807

assert ! issue.assigned_to.blank?

804

assert_equal @project, issue.project

808

assert_equal @project, issue.project

805

end

809

end

806

810

807

copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})

811

copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})

808

assert copied_issue

812

assert copied_issue

809

assert copied_issue.status

813

assert copied_issue.status

810

assert_equal "Closed", copied_issue.status.name

814

assert_equal "Closed", copied_issue.status.name

811

end

815

end

812

816

813

should "change the new issues to use the copied version" do

817

should "change the new issues to use the copied version" do

814

User.current = User.find(1)

818

User.current = User.find(1)

815

assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')

819

assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')

816

@source_project.versions << assigned_version

820

@source_project.versions << assigned_version

817

assert_equal 3, @source_project.versions.size

821

assert_equal 3, @source_project.versions.size

818

Issue.generate_for_project!(@source_project,

822

Issue.generate_for_project!(@source_project,

819

:fixed_version_id => assigned_version.id,

823

:fixed_version_id => assigned_version.id,

820

:subject => "change the new issues to use the copied version",

824

:subject => "change the new issues to use the copied version",

821

:tracker_id => 1,

825

:tracker_id => 1,

822

:project_id => @source_project.id)

826

:project_id => @source_project.id)

823

827

824

assert @project.copy(@source_project)

828

assert @project.copy(@source_project)

825

@project.reload

829

@project.reload

826

copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})

830

copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})

827

831

828

assert copied_issue

832

assert copied_issue

829

assert copied_issue.fixed_version

833

assert copied_issue.fixed_version

830

assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name

834

assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name

831

assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record

835

assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record

832

end

836

end

833

837

834

should "copy issue relations" do

838

should "copy issue relations" do

835

Setting.cross_project_issue_relations = '1'

839

Setting.cross_project_issue_relations = '1'

836

840

837

second_issue = Issue.generate!(:status_id => 5,

841

second_issue = Issue.generate!(:status_id => 5,

838

:subject => "copy issue relation",

842

:subject => "copy issue relation",

839

:tracker_id => 1,

843

:tracker_id => 1,

840

:assigned_to_id => 2,

844

:assigned_to_id => 2,

841

:project_id => @source_project.id)

845

:project_id => @source_project.id)

842

source_relation = IssueRelation.generate!(:issue_from => Issue.find(4),

846

source_relation = IssueRelation.generate!(:issue_from => Issue.find(4),

843

:issue_to => second_issue,

847

:issue_to => second_issue,

844

:relation_type => "relates")

848

:relation_type => "relates")

845

source_relation_cross_project = IssueRelation.generate!(:issue_from => Issue.find(1),

849

source_relation_cross_project = IssueRelation.generate!(:issue_from => Issue.find(1),

846

:issue_to => second_issue,

850

:issue_to => second_issue,

847

:relation_type => "duplicates")

851

:relation_type => "duplicates")

848

852

849

assert @project.copy(@source_project)

853

assert @project.copy(@source_project)

850

assert_equal @source_project.issues.count, @project.issues.count

854

assert_equal @source_project.issues.count, @project.issues.count

851

copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4

855

copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4

852

copied_second_issue = @project.issues.find_by_subject("copy issue relation")

856

copied_second_issue = @project.issues.find_by_subject("copy issue relation")

853

857

854

# First issue with a relation on project

858

# First issue with a relation on project

855

assert_equal 1, copied_issue.relations.size, "Relation not copied"

859

assert_equal 1, copied_issue.relations.size, "Relation not copied"

856

copied_relation = copied_issue.relations.first

860

copied_relation = copied_issue.relations.first

857

assert_equal "relates", copied_relation.relation_type

861

assert_equal "relates", copied_relation.relation_type

858

assert_equal copied_second_issue.id, copied_relation.issue_to_id

862

assert_equal copied_second_issue.id, copied_relation.issue_to_id

859

assert_not_equal source_relation.id, copied_relation.id

863

assert_not_equal source_relation.id, copied_relation.id

860

864

861

# Second issue with a cross project relation

865

# Second issue with a cross project relation

862

assert_equal 2, copied_second_issue.relations.size, "Relation not copied"

866

assert_equal 2, copied_second_issue.relations.size, "Relation not copied"

863

copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first

867

copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first

864

assert_equal "duplicates", copied_relation.relation_type

868

assert_equal "duplicates", copied_relation.relation_type

865

assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"

869

assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"

866

assert_not_equal source_relation_cross_project.id, copied_relation.id

870

assert_not_equal source_relation_cross_project.id, copied_relation.id

867

end

871

end

868

872

869

should "copy memberships" do

873

should "copy memberships" do

870

assert @project.valid?

874

assert @project.valid?

871

assert @project.members.empty?

875

assert @project.members.empty?

872

assert @project.copy(@source_project)

876

assert @project.copy(@source_project)

873

877

874

assert_equal @source_project.memberships.size, @project.memberships.size

878

assert_equal @source_project.memberships.size, @project.memberships.size

875

@project.memberships.each do |membership|

879

@project.memberships.each do |membership|

876

assert membership

880

assert membership

877

assert_equal @project, membership.project

881

assert_equal @project, membership.project

878

end

882

end

879

end

883

end

880

884

881

should "copy memberships with groups and additional roles" do

885

should "copy memberships with groups and additional roles" do

882

group = Group.create!(:lastname => "Copy group")

886

group = Group.create!(:lastname => "Copy group")

883

user = User.find(7)

887

user = User.find(7)

884

group.users << user

888

group.users << user

885

# group role

889

# group role

886

Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])

890

Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])

887

member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)

891

member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)

888

# additional role

892

# additional role

889

member.role_ids = [1]

893

member.role_ids = [1]

890

894

891

assert @project.copy(@source_project)

895

assert @project.copy(@source_project)

892

member = Member.find_by_user_id_and_project_id(user.id, @project.id)

896

member = Member.find_by_user_id_and_project_id(user.id, @project.id)

893

assert_not_nil member

897

assert_not_nil member

894

assert_equal [1, 2], member.role_ids.sort

898

assert_equal [1, 2], member.role_ids.sort

895

end

899

end

896

900

897

should "copy project specific queries" do

901

should "copy project specific queries" do

898

assert @project.valid?

902

assert @project.valid?

899

assert @project.queries.empty?

903

assert @project.queries.empty?

900

assert @project.copy(@source_project)

904

assert @project.copy(@source_project)

901

905

902

assert_equal @source_project.queries.size, @project.queries.size

906

assert_equal @source_project.queries.size, @project.queries.size

903

@project.queries.each do |query|

907

@project.queries.each do |query|

904

assert query

908

assert query

905

assert_equal @project, query.project

909

assert_equal @project, query.project

906

end

910

end

907

assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort

911

assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort

908

end

912

end

909

913

910

should "copy versions" do

914

should "copy versions" do

911

@source_project.versions << Version.generate!

915

@source_project.versions << Version.generate!

912

@source_project.versions << Version.generate!

916

@source_project.versions << Version.generate!

913

917

914

assert @project.versions.empty?

918

assert @project.versions.empty?

915

assert @project.copy(@source_project)

919

assert @project.copy(@source_project)

916

920

917

assert_equal @source_project.versions.size, @project.versions.size

921

assert_equal @source_project.versions.size, @project.versions.size

918

@project.versions.each do |version|

922

@project.versions.each do |version|

919

assert version

923

assert version

920

assert_equal @project, version.project

924

assert_equal @project, version.project

921

end

925

end

922

end

926

end

923

927

924

should "copy wiki" do

928

should "copy wiki" do

925

assert_difference 'Wiki.count' do

929

assert_difference 'Wiki.count' do

926

assert @project.copy(@source_project)

930

assert @project.copy(@source_project)

927

end

931

end

928

932

929

assert @project.wiki

933

assert @project.wiki

930

assert_not_equal @source_project.wiki, @project.wiki

934

assert_not_equal @source_project.wiki, @project.wiki

931

assert_equal "Start page", @project.wiki.start_page

935

assert_equal "Start page", @project.wiki.start_page

932

end

936

end

933

937

934

should "copy wiki pages and content with hierarchy" do

938

should "copy wiki pages and content with hierarchy" do

935

assert_difference 'WikiPage.count', @source_project.wiki.pages.size do

939

assert_difference 'WikiPage.count', @source_project.wiki.pages.size do

936

assert @project.copy(@source_project)

940

assert @project.copy(@source_project)

937

end

941

end

938

942

939

assert @project.wiki

943

assert @project.wiki

940

assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size

944

assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size

941

945

942

@project.wiki.pages.each do |wiki_page|

946

@project.wiki.pages.each do |wiki_page|

943

assert wiki_page.content

947

assert wiki_page.content

944

assert !@source_project.wiki.pages.include?(wiki_page)

948

assert !@source_project.wiki.pages.include?(wiki_page)

945

end

949

end

946

950

947

parent = @project.wiki.find_page('Parent_page')

951

parent = @project.wiki.find_page('Parent_page')

948

child1 = @project.wiki.find_page('Child_page_1')

952

child1 = @project.wiki.find_page('Child_page_1')

949

child2 = @project.wiki.find_page('Child_page_2')

953

child2 = @project.wiki.find_page('Child_page_2')

950

assert_equal parent, child1.parent

954

assert_equal parent, child1.parent

951

assert_equal parent, child2.parent

955

assert_equal parent, child2.parent

952

end

956

end

953

957

954

should "copy issue categories" do

958

should "copy issue categories" do

955

assert @project.copy(@source_project)

959

assert @project.copy(@source_project)

956

960

957

assert_equal 2, @project.issue_categories.size

961

assert_equal 2, @project.issue_categories.size

958

@project.issue_categories.each do |issue_category|

962

@project.issue_categories.each do |issue_category|

959

assert !@source_project.issue_categories.include?(issue_category)

963

assert !@source_project.issue_categories.include?(issue_category)

960

end

964

end

961

end

965

end

962

966

963

should "copy boards" do

967

should "copy boards" do

964

assert @project.copy(@source_project)

968

assert @project.copy(@source_project)

965

969

966

assert_equal 1, @project.boards.size

970

assert_equal 1, @project.boards.size

967

@project.boards.each do |board|

971

@project.boards.each do |board|

968

assert !@source_project.boards.include?(board)

972

assert !@source_project.boards.include?(board)

969

end

973

end

970

end

974

end

971

975

972

should "change the new issues to use the copied issue categories" do

976

should "change the new issues to use the copied issue categories" do

973

issue = Issue.find(4)

977

issue = Issue.find(4)

974

issue.update_attribute(:category_id, 3)

978

issue.update_attribute(:category_id, 3)

975

979

976

assert @project.copy(@source_project)

980

assert @project.copy(@source_project)

977

981

978

@project.issues.each do |issue|

982

@project.issues.each do |issue|

979

assert issue.category

983

assert issue.category

980

assert_equal "Stock management", issue.category.name # Same name

984

assert_equal "Stock management", issue.category.name # Same name

981

assert_not_equal IssueCategory.find(3), issue.category # Different record

985

assert_not_equal IssueCategory.find(3), issue.category # Different record

982

end

986

end

983

end

987

end

984

988

985

should "limit copy with :only option" do

989

should "limit copy with :only option" do

986

assert @project.members.empty?

990

assert @project.members.empty?

987

assert @project.issue_categories.empty?

991

assert @project.issue_categories.empty?

988

assert @source_project.issues.any?

992

assert @source_project.issues.any?

989

993

990

assert @project.copy(@source_project, :only => ['members', 'issue_categories'])

994

assert @project.copy(@source_project, :only => ['members', 'issue_categories'])

991

995

992

assert @project.members.any?

996

assert @project.members.any?

993

assert @project.issue_categories.any?

997

assert @project.issue_categories.any?

994

assert @project.issues.empty?

998

assert @project.issues.empty?

995

end

999

end

996

1000

997

end

1001

end

998

1002

999

context "#start_date" do

1003

context "#start_date" do

1000

setup do

1004

setup do

1001

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1005

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1002

@project = Project.generate!(:identifier => 'test0')

1006

@project = Project.generate!(:identifier => 'test0')

1003

@project.trackers << Tracker.generate!

1007

@project.trackers << Tracker.generate!

1004

end

1008

end

1005

1009

1006

should "be nil if there are no issues on the project" do

1010

should "be nil if there are no issues on the project" do

1007

assert_nil @project.start_date

1011

assert_nil @project.start_date

1008

end

1012

end

1009

1013

1010

should "be tested when issues have no start date"

1014

should "be tested when issues have no start date"

1011

1015

1012

should "be the earliest start date of it's issues" do

1016

should "be the earliest start date of it's issues" do

1013

early = 7.days.ago.to_date

1017

early = 7.days.ago.to_date

1014

Issue.generate_for_project!(@project, :start_date => Date.today)

1018

Issue.generate_for_project!(@project, :start_date => Date.today)

1015

Issue.generate_for_project!(@project, :start_date => early)

1019

Issue.generate_for_project!(@project, :start_date => early)

1016

1020

1017

assert_equal early, @project.start_date

1021

assert_equal early, @project.start_date

1018

end

1022

end

1019

1023

1020

end

1024

end

1021

1025

1022

context "#due_date" do

1026

context "#due_date" do

1023

setup do

1027

setup do

1024

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1028

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1025

@project = Project.generate!(:identifier => 'test0')

1029

@project = Project.generate!(:identifier => 'test0')

1026

@project.trackers << Tracker.generate!

1030

@project.trackers << Tracker.generate!

1027

end

1031

end

1028

1032

1029

should "be nil if there are no issues on the project" do

1033

should "be nil if there are no issues on the project" do

1030

assert_nil @project.due_date

1034

assert_nil @project.due_date

1031

end

1035

end

1032

1036

1033

should "be tested when issues have no due date"

1037

should "be tested when issues have no due date"

1034

1038

1035

should "be the latest due date of it's issues" do

1039

should "be the latest due date of it's issues" do

1036

future = 7.days.from_now.to_date

1040

future = 7.days.from_now.to_date

1037

Issue.generate_for_project!(@project, :due_date => future)

1041

Issue.generate_for_project!(@project, :due_date => future)

1038

Issue.generate_for_project!(@project, :due_date => Date.today)

1042

Issue.generate_for_project!(@project, :due_date => Date.today)

1039

1043

1040

assert_equal future, @project.due_date

1044

assert_equal future, @project.due_date

1041

end

1045

end

1042

1046

1043

should "be the latest due date of it's versions" do

1047

should "be the latest due date of it's versions" do

1044

future = 7.days.from_now.to_date

1048

future = 7.days.from_now.to_date

1045

@project.versions << Version.generate!(:effective_date => future)

1049

@project.versions << Version.generate!(:effective_date => future)

1046

@project.versions << Version.generate!(:effective_date => Date.today)

1050

@project.versions << Version.generate!(:effective_date => Date.today)

1047

1051

1048

1052

1049

assert_equal future, @project.due_date

1053

assert_equal future, @project.due_date

1050

1054

1051

end

1055

end

1052

1056

1053

should "pick the latest date from it's issues and versions" do

1057

should "pick the latest date from it's issues and versions" do

1054

future = 7.days.from_now.to_date

1058

future = 7.days.from_now.to_date

1055

far_future = 14.days.from_now.to_date

1059

far_future = 14.days.from_now.to_date

1056

Issue.generate_for_project!(@project, :due_date => far_future)

1060

Issue.generate_for_project!(@project, :due_date => far_future)

1057

@project.versions << Version.generate!(:effective_date => future)

1061

@project.versions << Version.generate!(:effective_date => future)

1058

1062

1059

assert_equal far_future, @project.due_date

1063

assert_equal far_future, @project.due_date

1060

end

1064

end

1061

1065

1062

end

1066

end

1063

1067

1064

context "Project#completed_percent" do

1068

context "Project#completed_percent" do

1065

setup do

1069

setup do

1066

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1070

ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests

1067

@project = Project.generate!(:identifier => 'test0')

1071

@project = Project.generate!(:identifier => 'test0')

1068

@project.trackers << Tracker.generate!

1072

@project.trackers << Tracker.generate!

1069

end

1073

end

1070

1074

1071

context "no versions" do

1075

context "no versions" do

1072

should "be 100" do

1076

should "be 100" do

1073

assert_equal 100, @project.completed_percent

1077

assert_equal 100, @project.completed_percent

1074

end

1078

end

1075

end

1079

end

1076

1080

1077

context "with versions" do

1081

context "with versions" do

1078

should "return 0 if the versions have no issues" do

1082

should "return 0 if the versions have no issues" do

1079

Version.generate!(:project => @project)

1083

Version.generate!(:project => @project)

1080

Version.generate!(:project => @project)

1084

Version.generate!(:project => @project)

1081

1085

1082

assert_equal 0, @project.completed_percent

1086

assert_equal 0, @project.completed_percent

1083

end

1087

end

1084

1088

1085

should "return 100 if the version has only closed issues" do

1089

should "return 100 if the version has only closed issues" do

1086

v1 = Version.generate!(:project => @project)

1090

v1 = Version.generate!(:project => @project)

1087

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)

1091

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)

1088

v2 = Version.generate!(:project => @project)

1092

v2 = Version.generate!(:project => @project)

1089

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)

1093

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)

1090

1094

1091

assert_equal 100, @project.completed_percent

1095

assert_equal 100, @project.completed_percent

1092

end

1096

end

1093

1097

1094

should "return the averaged completed percent of the versions (not weighted)" do

1098

should "return the averaged completed percent of the versions (not weighted)" do

1095

v1 = Version.generate!(:project => @project)

1099

v1 = Version.generate!(:project => @project)

1096

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)

1100

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)

1097

v2 = Version.generate!(:project => @project)

1101

v2 = Version.generate!(:project => @project)

1098

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)

1102

Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)

1099

1103

1100

assert_equal 50, @project.completed_percent

1104

assert_equal 50, @project.completed_percent

1101

end

1105

end

1102

1106

1103

end

1107

end

1104

end

1108

end

1105

1109

1106

context "#notified_users" do

1110

context "#notified_users" do

1107

setup do

1111

setup do

1108

@project = Project.generate!

1112

@project = Project.generate!

1109

@role = Role.generate!

1113

@role = Role.generate!

1110

1114

1111

@user_with_membership_notification = User.generate!(:mail_notification => 'selected')

1115

@user_with_membership_notification = User.generate!(:mail_notification => 'selected')

1112

Member.generate!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)

1116

Member.generate!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)

1113

1117

1114

@all_events_user = User.generate!(:mail_notification => 'all')

1118

@all_events_user = User.generate!(:mail_notification => 'all')

1115

Member.generate!(:project => @project, :roles => [@role], :principal => @all_events_user)

1119

Member.generate!(:project => @project, :roles => [@role], :principal => @all_events_user)

1116

1120

1117

@no_events_user = User.generate!(:mail_notification => 'none')

1121

@no_events_user = User.generate!(:mail_notification => 'none')

1118

Member.generate!(:project => @project, :roles => [@role], :principal => @no_events_user)

1122

Member.generate!(:project => @project, :roles => [@role], :principal => @no_events_user)

1119

1123

1120

@only_my_events_user = User.generate!(:mail_notification => 'only_my_events')

1124

@only_my_events_user = User.generate!(:mail_notification => 'only_my_events')

1121

Member.generate!(:project => @project, :roles => [@role], :principal => @only_my_events_user)

1125

Member.generate!(:project => @project, :roles => [@role], :principal => @only_my_events_user)

1122

1126

1123

@only_assigned_user = User.generate!(:mail_notification => 'only_assigned')

1127

@only_assigned_user = User.generate!(:mail_notification => 'only_assigned')

1124

Member.generate!(:project => @project, :roles => [@role], :principal => @only_assigned_user)

1128

Member.generate!(:project => @project, :roles => [@role], :principal => @only_assigned_user)

1125

1129

1126

@only_owned_user = User.generate!(:mail_notification => 'only_owner')

1130

@only_owned_user = User.generate!(:mail_notification => 'only_owner')

1127

Member.generate!(:project => @project, :roles => [@role], :principal => @only_owned_user)

1131

Member.generate!(:project => @project, :roles => [@role], :principal => @only_owned_user)

1128

end

1132

end

1129

1133

1130

should "include members with a mail notification" do

1134

should "include members with a mail notification" do

1131

assert @project.notified_users.include?(@user_with_membership_notification)

1135

assert @project.notified_users.include?(@user_with_membership_notification)

1132

end

1136

end

1133

1137

1134

should "include users with the 'all' notification option" do

1138

should "include users with the 'all' notification option" do

1135

assert @project.notified_users.include?(@all_events_user)

1139

assert @project.notified_users.include?(@all_events_user)

1136

end

1140

end

1137

1141

1138

should "not include users with the 'none' notification option" do

1142

should "not include users with the 'none' notification option" do

1139

assert !@project.notified_users.include?(@no_events_user)

1143

assert !@project.notified_users.include?(@no_events_user)

1140

end

1144

end

1141

1145

1142

should "not include users with the 'only_my_events' notification option" do

1146

should "not include users with the 'only_my_events' notification option" do

1143

assert !@project.notified_users.include?(@only_my_events_user)

1147

assert !@project.notified_users.include?(@only_my_events_user)

1144

end

1148

end

1145

1149

1146

should "not include users with the 'only_assigned' notification option" do

1150

should "not include users with the 'only_assigned' notification option" do

1147

assert !@project.notified_users.include?(@only_assigned_user)

1151

assert !@project.notified_users.include?(@only_assigned_user)

1148

end

1152

end

1149

1153

1150

should "not include users with the 'only_owner' notification option" do

1154

should "not include users with the 'only_owner' notification option" do

1151

assert !@project.notified_users.include?(@only_owned_user)

1155

assert !@project.notified_users.include?(@only_owned_user)

1152

end

1156

end

1153

end

1157

end

1154

1158

1155

end

1159

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 ProjectTest < ActiveSupport::TestCase
               fixtures :projects, :trackers, :issue_statuses, :issues,
                        :journals, :journal_details,
                        :enumerations, :users, :issue_categories,
                        :projects_trackers,
                        :custom_fields,
                        :custom_fields_projects,
                        :custom_fields_trackers,
                        :custom_values,
                        :roles,
                        :member_roles,
                        :members,
                        :enabled_modules,
                        :workflows,
                        :versions,
                        :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                        :groups_users,
                        :boards,
                        :repositories
               def setup
                 @ecookbook = Project.find(1)
                 @ecookbook_sub1 = Project.find(3)
                 set_tmp_attachments_directory
                 User.current = nil
               end
               should_validate_presence_of :name
               should_validate_presence_of :identifier
               should_validate_uniqueness_of :identifier
               context "associations" do
                 should_have_many :members
                 should_have_many :users, :through => :members
                 should_have_many :member_principals
                 should_have_many :principals, :through => :member_principals
                 should_have_many :enabled_modules
                 should_have_many :issues
                 should_have_many :issue_changes, :through => :issues
                 should_have_many :versions
                 should_have_many :time_entries
                 should_have_many :queries
                 should_have_many :documents
                 should_have_many :news
                 should_have_many :issue_categories
                 should_have_many :boards
                 should_have_many :changesets, :through => :repository
                 should_have_one :repository
                 should_have_one :wiki
                 should_have_and_belong_to_many :trackers
                 should_have_and_belong_to_many :issue_custom_fields
               end
               def test_truth
                 assert_kind_of Project, @ecookbook
                 assert_equal "eCookbook", @ecookbook.name
               end
               def test_default_attributes
                 with_settings :default_projects_public => '1' do
                   assert_equal true, Project.new.is_public
                   assert_equal false, Project.new(:is_public => false).is_public
                 end
                 with_settings :default_projects_public => '0' do
                   assert_equal false, Project.new.is_public
                   assert_equal true, Project.new(:is_public => true).is_public
                 end
                 with_settings :sequential_project_identifiers => '1' do
                   assert !Project.new.identifier.blank?
                   assert Project.new(:identifier => '').identifier.blank?
                 end
                 with_settings :sequential_project_identifiers => '0' do
                   assert Project.new.identifier.blank?
                   assert !Project.new(:identifier => 'test').blank?
                 end
                 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                   assert_equal ['issue_tracking', 'repository'], Project.new.enabled_module_names
                 end
                 assert_equal Tracker.all, Project.new.trackers
                 assert_equal Tracker.find(1, 3), Project.new(:tracker_ids => [1, 3]).trackers
               end
               def test_update
                 assert_equal "eCookbook", @ecookbook.name
                 @ecookbook.name = "eCook"
                 assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
                 @ecookbook.reload
                 assert_equal "eCook", @ecookbook.name
               end
               def test_validate_identifier
                 to_test = {"abc" => true,
                            "ab12" => true,
                            "ab-12" => true,
                            "12" => false,
                            "new" => false}
                 to_test.each do |identifier, valid|
                   p = Project.new
                   p.identifier = identifier
                   p.valid?
-                  assert_equal valid, p.errors['identifier'].nil?
+                  if valid
+                    assert p.errors['identifier'].blank?, "identifier #{identifier} was not valid"
+                  else
+                    assert p.errors['identifier'].present?, "identifier #{identifier} was valid"
+                  end
                 end
               end
               def test_members_should_be_active_users
                 Project.all.each do |project|
                   assert_nil project.members.detect {|m| !(m.user.is_a?(User) && m.user.active?) }
                 end
               end
               def test_users_should_be_active_users
                 Project.all.each do |project|
                   assert_nil project.users.detect {|u| !(u.is_a?(User) && u.active?) }
                 end
               end
               def test_archive
                 user = @ecookbook.members.first.user
                 @ecookbook.archive
                 @ecookbook.reload
                 assert !@ecookbook.active?
                 assert @ecookbook.archived?
                 assert !user.projects.include?(@ecookbook)
                 # Subproject are also archived
                 assert !@ecookbook.children.empty?
                 assert @ecookbook.descendants.active.empty?
               end
               def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects
                 # Assign an issue of a project to a version of a child project
                 Issue.find(4).update_attribute :fixed_version_id, 4
                 assert_no_difference "Project.count(:all, :conditions => 'status = #{Project::STATUS_ARCHIVED}')" do
                   assert_equal false, @ecookbook.archive
                 end
                 @ecookbook.reload
                 assert @ecookbook.active?
               end
               def test_unarchive
                 user = @ecookbook.members.first.user
                 @ecookbook.archive
                 # A subproject of an archived project can not be unarchived
                 assert !@ecookbook_sub1.unarchive
                 # Unarchive project
                 assert @ecookbook.unarchive
                 @ecookbook.reload
                 assert @ecookbook.active?
                 assert !@ecookbook.archived?
                 assert user.projects.include?(@ecookbook)
                 # Subproject can now be unarchived
                 @ecookbook_sub1.reload
                 assert @ecookbook_sub1.unarchive
               end
               def test_destroy
                 # 2 active members
                 assert_equal 2, @ecookbook.members.size
                 # and 1 is locked
                 assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size
                 # some boards
                 assert @ecookbook.boards.any?
                 @ecookbook.destroy
                 # make sure that the project non longer exists
                 assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
                 # make sure related data was removed
                 assert_nil Member.first(:conditions => {:project_id => @ecookbook.id})
                 assert_nil Board.first(:conditions => {:project_id => @ecookbook.id})
                 assert_nil Issue.first(:conditions => {:project_id => @ecookbook.id})
               end
               def test_destroying_root_projects_should_clear_data
                 Project.roots.each do |root|
                   root.destroy
                 end
                 assert_equal 0, Project.count, "Projects were not deleted: #{Project.all.inspect}"
                 assert_equal 0, Member.count, "Members were not deleted: #{Member.all.inspect}"
                 assert_equal 0, MemberRole.count
                 assert_equal 0, Issue.count
                 assert_equal 0, Journal.count
                 assert_equal 0, JournalDetail.count
                 assert_equal 0, Attachment.count
                 assert_equal 0, EnabledModule.count
                 assert_equal 0, IssueCategory.count
                 assert_equal 0, IssueRelation.count
                 assert_equal 0, Board.count
                 assert_equal 0, Message.count
                 assert_equal 0, News.count
                 assert_equal 0, Query.count(:conditions => "project_id IS NOT NULL")
                 assert_equal 0, Repository.count
                 assert_equal 0, Changeset.count
                 assert_equal 0, Change.count
                 assert_equal 0, Comment.count
                 assert_equal 0, TimeEntry.count
                 assert_equal 0, Version.count
                 assert_equal 0, Watcher.count
                 assert_equal 0, Wiki.count
                 assert_equal 0, WikiPage.count
                 assert_equal 0, WikiContent.count
                 assert_equal 0, WikiContent::Version.count
                 assert_equal 0, Project.connection.select_all("SELECT * FROM projects_trackers").size
                 assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").size
                 assert_equal 0, CustomValue.count(:conditions => {:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']})
               end
               def test_move_an_orphan_project_to_a_root_project
                 sub = Project.find(2)
                 sub.set_parent! @ecookbook
                 assert_equal @ecookbook.id, sub.parent.id
                 @ecookbook.reload
                 assert_equal 4, @ecookbook.children.size
               end
               def test_move_an_orphan_project_to_a_subproject
                 sub = Project.find(2)
                 assert sub.set_parent!(@ecookbook_sub1)
               end
               def test_move_a_root_project_to_a_project
                 sub = @ecookbook
                 assert sub.set_parent!(Project.find(2))
               end
               def test_should_not_move_a_project_to_its_children
                 sub = @ecookbook
                 assert !(sub.set_parent!(Project.find(3)))
               end
               def test_set_parent_should_add_roots_in_alphabetical_order
                 ProjectCustomField.delete_all
                 Project.delete_all
                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
                 assert_equal 4, Project.count
                 assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
               end
               def test_set_parent_should_add_children_in_alphabetical_order
                 ProjectCustomField.delete_all
                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
                 parent.reload
                 assert_equal 4, parent.children.size
                 assert_equal parent.children.all.sort_by(&:name), parent.children.all
               end
               def test_rebuild_should_sort_children_alphabetically
                 ProjectCustomField.delete_all
                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
                 Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)
                 Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)
                 Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)
                 Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)
                 Project.update_all("lft = NULL, rgt = NULL")
                 Project.rebuild!
                 parent.reload
                 assert_equal 4, parent.children.size
                 assert_equal parent.children.all.sort_by(&:name), parent.children.all
               end
               def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy
                 # Parent issue with a hierarchy project's fixed version
                 parent_issue = Issue.find(1)
                 parent_issue.update_attribute(:fixed_version_id, 4)
                 parent_issue.reload
                 assert_equal 4, parent_issue.fixed_version_id
                 # Should keep fixed versions for the issues
                 issue_with_local_fixed_version = Issue.find(5)
                 issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)
                 issue_with_local_fixed_version.reload
                 assert_equal 4, issue_with_local_fixed_version.fixed_version_id
                 # Local issue with hierarchy fixed_version
                 issue_with_hierarchy_fixed_version = Issue.find(13)
                 issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)
                 issue_with_hierarchy_fixed_version.reload
                 assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id
                 # Move project out of the issue's hierarchy
                 moved_project = Project.find(3)
                 moved_project.set_parent!(Project.find(2))
                 parent_issue.reload
                 issue_with_local_fixed_version.reload
                 issue_with_hierarchy_fixed_version.reload
                 assert_equal 4, issue_with_local_fixed_version.fixed_version_id, "Fixed version was not keep on an issue local to the moved project"
                 assert_equal nil, issue_with_hierarchy_fixed_version.fixed_version_id, "Fixed version is still set after moving the Project out of the hierarchy where the version is defined in"
                 assert_equal nil, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."
               end
               def test_parent
                 p = Project.find(6).parent
                 assert p.is_a?(Project)
                 assert_equal 5, p.id
               end
               def test_ancestors
                 a = Project.find(6).ancestors
                 assert a.first.is_a?(Project)
                 assert_equal [1, 5], a.collect(&:id)
               end
               def test_root
                 r = Project.find(6).root
                 assert r.is_a?(Project)
                 assert_equal 1, r.id
               end
               def test_children
                 c = Project.find(1).children
                 assert c.first.is_a?(Project)
                 assert_equal [5, 3, 4], c.collect(&:id)
               end
               def test_descendants
                 d = Project.find(1).descendants
                 assert d.first.is_a?(Project)
                 assert_equal [5, 6, 3, 4], d.collect(&:id)
               end
               def test_allowed_parents_should_be_empty_for_non_member_user
                 Role.non_member.add_permission!(:add_project)
                 user = User.find(9)
                 assert user.memberships.empty?
                 User.current = user
                 assert Project.new.allowed_parents.compact.empty?
               end
               def test_allowed_parents_with_add_subprojects_permission
                 Role.find(1).remove_permission!(:add_project)
                 Role.find(1).add_permission!(:add_subprojects)
                 User.current = User.find(2)
                 # new project
                 assert !Project.new.allowed_parents.include?(nil)
                 assert Project.new.allowed_parents.include?(Project.find(1))
                 # existing root project
                 assert Project.find(1).allowed_parents.include?(nil)
                 # existing child
                 assert Project.find(3).allowed_parents.include?(Project.find(1))
                 assert !Project.find(3).allowed_parents.include?(nil)
               end
               def test_allowed_parents_with_add_project_permission
                 Role.find(1).add_permission!(:add_project)
                 Role.find(1).remove_permission!(:add_subprojects)
                 User.current = User.find(2)
                 # new project
                 assert Project.new.allowed_parents.include?(nil)
                 assert !Project.new.allowed_parents.include?(Project.find(1))
                 # existing root project
                 assert Project.find(1).allowed_parents.include?(nil)
                 # existing child
                 assert Project.find(3).allowed_parents.include?(Project.find(1))
                 assert Project.find(3).allowed_parents.include?(nil)
               end
               def test_allowed_parents_with_add_project_and_subprojects_permission
                 Role.find(1).add_permission!(:add_project)
                 Role.find(1).add_permission!(:add_subprojects)
                 User.current = User.find(2)
                 # new project
                 assert Project.new.allowed_parents.include?(nil)
                 assert Project.new.allowed_parents.include?(Project.find(1))
                 # existing root project
                 assert Project.find(1).allowed_parents.include?(nil)
                 # existing child
                 assert Project.find(3).allowed_parents.include?(Project.find(1))
                 assert Project.find(3).allowed_parents.include?(nil)
               end
               def test_users_by_role
                 users_by_role = Project.find(1).users_by_role
                 assert_kind_of Hash, users_by_role
                 role = Role.find(1)
                 assert_kind_of Array, users_by_role[role]
                 assert users_by_role[role].include?(User.find(2))
               end
               def test_rolled_up_trackers
                 parent = Project.find(1)
                 parent.trackers = Tracker.find([1,2])
                 child = parent.children.find(3)
                 assert_equal [1, 2], parent.tracker_ids
                 assert_equal [2, 3], child.trackers.collect(&:id)
                 assert_kind_of Tracker, parent.rolled_up_trackers.first
                 assert_equal Tracker.find(1), parent.rolled_up_trackers.first
                 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
                 assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
               end
               def test_rolled_up_trackers_should_ignore_archived_subprojects
                 parent = Project.find(1)
                 parent.trackers = Tracker.find([1,2])
                 child = parent.children.find(3)
                 child.trackers = Tracker.find([1,3])
                 parent.children.each(&:archive)
                 assert_equal [1,2], parent.rolled_up_trackers.collect(&:id)
               end
               context "#rolled_up_versions" do
                 setup do
                   @project = Project.generate!
                   @parent_version_1 = Version.generate!(:project => @project)
                   @parent_version_2 = Version.generate!(:project => @project)
                 end
                 should "include the versions for the current project" do
                   assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
                 end
                 should "include versions for a subproject" do
                   @subproject = Project.generate!
                   @subproject.set_parent!(@project)
                   @subproject_version = Version.generate!(:project => @subproject)
                   assert_same_elements [
                                         @parent_version_1,
                                         @parent_version_2,
                                         @subproject_version
                                        ], @project.rolled_up_versions
                 end
                 should "include versions for a sub-subproject" do
                   @subproject = Project.generate!
                   @subproject.set_parent!(@project)
                   @sub_subproject = Project.generate!
                   @sub_subproject.set_parent!(@subproject)
                   @sub_subproject_version = Version.generate!(:project => @sub_subproject)
                   @project.reload
                   assert_same_elements [
                                         @parent_version_1,
                                         @parent_version_2,
                                         @sub_subproject_version
                                        ], @project.rolled_up_versions
                 end
                 should "only check active projects" do
                   @subproject = Project.generate!
                   @subproject.set_parent!(@project)
                   @subproject_version = Version.generate!(:project => @subproject)
                   assert @subproject.archive
                   @project.reload
                   assert !@subproject.active?
                   assert_same_elements [@parent_version_1, @parent_version_2], @project.rolled_up_versions
                 end
               end
               def test_shared_versions_none_sharing
                 p = Project.find(5)
                 v = Version.create!(:name => 'none_sharing', :project => p, :sharing => 'none')
                 assert p.shared_versions.include?(v)
                 assert !p.children.first.shared_versions.include?(v)
                 assert !p.root.shared_versions.include?(v)
                 assert !p.siblings.first.shared_versions.include?(v)
                 assert !p.root.siblings.first.shared_versions.include?(v)
               end
               def test_shared_versions_descendants_sharing
                 p = Project.find(5)
                 v = Version.create!(:name => 'descendants_sharing', :project => p, :sharing => 'descendants')
                 assert p.shared_versions.include?(v)
                 assert p.children.first.shared_versions.include?(v)
                 assert !p.root.shared_versions.include?(v)
                 assert !p.siblings.first.shared_versions.include?(v)
                 assert !p.root.siblings.first.shared_versions.include?(v)
               end
               def test_shared_versions_hierarchy_sharing
                 p = Project.find(5)
                 v = Version.create!(:name => 'hierarchy_sharing', :project => p, :sharing => 'hierarchy')
                 assert p.shared_versions.include?(v)
                 assert p.children.first.shared_versions.include?(v)
                 assert p.root.shared_versions.include?(v)
                 assert !p.siblings.first.shared_versions.include?(v)
                 assert !p.root.siblings.first.shared_versions.include?(v)
               end
               def test_shared_versions_tree_sharing
                 p = Project.find(5)
                 v = Version.create!(:name => 'tree_sharing', :project => p, :sharing => 'tree')
                 assert p.shared_versions.include?(v)
                 assert p.children.first.shared_versions.include?(v)
                 assert p.root.shared_versions.include?(v)
                 assert p.siblings.first.shared_versions.include?(v)
                 assert !p.root.siblings.first.shared_versions.include?(v)
               end
               def test_shared_versions_system_sharing
                 p = Project.find(5)
                 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                 assert p.shared_versions.include?(v)
                 assert p.children.first.shared_versions.include?(v)
                 assert p.root.shared_versions.include?(v)
                 assert p.siblings.first.shared_versions.include?(v)
                 assert p.root.siblings.first.shared_versions.include?(v)
               end
               def test_shared_versions
                 parent = Project.find(1)
                 child = parent.children.find(3)
                 private_child = parent.children.find(5)
                 assert_equal [1,2,3], parent.version_ids.sort
                 assert_equal [4], child.version_ids
                 assert_equal [6], private_child.version_ids
                 assert_equal [7], Version.find_all_by_sharing('system').collect(&:id)
                 assert_equal 6, parent.shared_versions.size
                 parent.shared_versions.each do |version|
                   assert_kind_of Version, version
                 end
                 assert_equal [1,2,3,4,6,7], parent.shared_versions.collect(&:id).sort
               end
               def test_shared_versions_should_ignore_archived_subprojects
                 parent = Project.find(1)
                 child = parent.children.find(3)
                 child.archive
                 parent.reload
                 assert_equal [1,2,3], parent.version_ids.sort
                 assert_equal [4], child.version_ids
                 assert !parent.shared_versions.collect(&:id).include?(4)
               end
               def test_shared_versions_visible_to_user
                 user = User.find(3)
                 parent = Project.find(1)
                 child = parent.children.find(5)
                 assert_equal [1,2,3], parent.version_ids.sort
                 assert_equal [6], child.version_ids
                 versions = parent.shared_versions.visible(user)
                 assert_equal 4, versions.size
                 versions.each do |version|
                   assert_kind_of Version, version
                 end
                 assert !versions.collect(&:id).include?(6)
               end
               def test_next_identifier
                 ProjectCustomField.delete_all
                 Project.create!(:name => 'last', :identifier => 'p2008040')
                 assert_equal 'p2008041', Project.next_identifier
               end
               def test_next_identifier_first_project
                 Project.delete_all
                 assert_nil Project.next_identifier
               end
               def test_enabled_module_names
                 with_settings :default_projects_modules => ['issue_tracking', 'repository'] do
                   project = Project.new
                   project.enabled_module_names = %w(issue_tracking news)
                   assert_equal %w(issue_tracking news), project.enabled_module_names.sort
                 end
               end
               context "enabled_modules" do
                 setup do
                   @project = Project.find(1)
                 end
                 should "define module by names and preserve ids" do
                   # Remove one module
                   modules = @project.enabled_modules.slice(0..-2)
                   assert modules.any?
                   assert_difference 'EnabledModule.count', -1 do
                     @project.enabled_module_names = modules.collect(&:name)
                   end
                   @project.reload
                   # Ids should be preserved
                   assert_equal @project.enabled_module_ids.sort, modules.collect(&:id).sort
                 end
                 should "enable a module" do
                   @project.enabled_module_names = []
                   @project.reload
                   assert_equal [], @project.enabled_module_names
                   #with string
                   @project.enable_module!("issue_tracking")
                   assert_equal ["issue_tracking"], @project.enabled_module_names
                   #with symbol
                   @project.enable_module!(:gantt)
                   assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                   #don't add a module twice
                   @project.enable_module!("issue_tracking")
                   assert_equal ["issue_tracking", "gantt"], @project.enabled_module_names
                 end
                 should "disable a module" do
                   #with string
                   assert @project.enabled_module_names.include?("issue_tracking")
                   @project.disable_module!("issue_tracking")
                   assert ! @project.reload.enabled_module_names.include?("issue_tracking")
                   #with symbol
                   assert @project.enabled_module_names.include?("gantt")
                   @project.disable_module!(:gantt)
                   assert ! @project.reload.enabled_module_names.include?("gantt")
                   #with EnabledModule object
                   first_module = @project.enabled_modules.first
                   @project.disable_module!(first_module)
                   assert ! @project.reload.enabled_module_names.include?(first_module.name)
                 end
               end
               def test_enabled_module_names_should_not_recreate_enabled_modules
                 project = Project.find(1)
                 # Remove one module
                 modules = project.enabled_modules.slice(0..-2)
                 assert modules.any?
                 assert_difference 'EnabledModule.count', -1 do
                   project.enabled_module_names = modules.collect(&:name)
                 end
                 project.reload
                 # Ids should be preserved
                 assert_equal project.enabled_module_ids.sort, modules.collect(&:id).sort
               end
               def test_copy_from_existing_project
                 source_project = Project.find(1)
                 copied_project = Project.copy_from(1)
                 assert copied_project
                 # Cleared attributes
                 assert copied_project.id.blank?
                 assert copied_project.name.blank?
                 assert copied_project.identifier.blank?
                 # Duplicated attributes
                 assert_equal source_project.description, copied_project.description
                 assert_equal source_project.enabled_modules, copied_project.enabled_modules
                 assert_equal source_project.trackers, copied_project.trackers
                 # Default attributes
                 assert_equal 1, copied_project.status
               end
               def test_activities_should_use_the_system_activities
                 project = Project.find(1)
                 assert_equal project.activities, TimeEntryActivity.find(:all, :conditions => {:active => true} )
               end
               def test_activities_should_use_the_project_specific_activities
                 project = Project.find(1)
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project})
                 assert overridden_activity.save!
                 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
               end
               def test_activities_should_not_include_the_inactive_project_specific_activities
                 project = Project.find(1)
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
                 assert overridden_activity.save!
                 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity found"
               end
               def test_activities_should_not_include_project_specific_activities_from_other_projects
                 project = Project.find(1)
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(2)})
                 assert overridden_activity.save!
                 assert !project.activities.include?(overridden_activity), "Project specific Activity found on a different project"
               end
               def test_activities_should_handle_nils
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => Project.find(1), :parent => TimeEntryActivity.find(:first)})
                 TimeEntryActivity.delete_all
                 # No activities
                 project = Project.find(1)
                 assert project.activities.empty?
                 # No system, one overridden
                 assert overridden_activity.save!
                 project.reload
                 assert_equal [overridden_activity], project.activities
               end
               def test_activities_should_override_system_activities_with_project_activities
                 project = Project.find(1)
                 parent_activity = TimeEntryActivity.find(:first)
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => parent_activity})
                 assert overridden_activity.save!
                 assert project.activities.include?(overridden_activity), "Project specific Activity not found"
                 assert !project.activities.include?(parent_activity), "System Activity found when it should have been overridden"
               end
               def test_activities_should_include_inactive_activities_if_specified
                 project = Project.find(1)
                 overridden_activity = TimeEntryActivity.new({:name => "Project", :project => project, :parent => TimeEntryActivity.find(:first), :active => false})
                 assert overridden_activity.save!
                 assert project.activities(true).include?(overridden_activity), "Inactive Project specific Activity not found"
               end
               test 'activities should not include active System activities if the project has an override that is inactive' do
                 project = Project.find(1)
                 system_activity = TimeEntryActivity.find_by_name('Design')
                 assert system_activity.active?
                 overridden_activity = TimeEntryActivity.generate!(:project => project, :parent => system_activity, :active => false)
                 assert overridden_activity.save!
                 assert !project.activities.include?(overridden_activity), "Inactive Project specific Activity not found"
                 assert !project.activities.include?(system_activity), "System activity found when the project has an inactive override"
               end
               def test_close_completed_versions
                 Version.update_all("status = 'open'")
                 project = Project.find(1)
                 assert_not_nil project.versions.detect {|v| v.completed? && v.status == 'open'}
                 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
                 project.close_completed_versions
                 project.reload
                 assert_nil project.versions.detect {|v| v.completed? && v.status != 'closed'}
                 assert_not_nil project.versions.detect {|v| !v.completed? && v.status == 'open'}
               end
               context "Project#copy" do
                 setup do
                   ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                   Project.destroy_all :identifier => "copy-test"
                   @source_project = Project.find(2)
                   @project = Project.new(:name => 'Copy Test', :identifier => 'copy-test')
                   @project.trackers = @source_project.trackers
                   @project.enabled_module_names = @source_project.enabled_modules.collect(&:name)
                 end
                 should "copy issues" do
                   @source_project.issues << Issue.generate!(:status => IssueStatus.find_by_name('Closed'),
                                                             :subject => "copy issue status",
                                                             :tracker_id => 1,
                                                             :assigned_to_id => 2,
                                                             :project_id => @source_project.id)
                   assert @project.valid?
                   assert @project.issues.empty?
                   assert @project.copy(@source_project)
                   assert_equal @source_project.issues.size, @project.issues.size
                   @project.issues.each do |issue|
                     assert issue.valid?
                     assert ! issue.assigned_to.blank?
                     assert_equal @project, issue.project
                   end
                   copied_issue = @project.issues.first(:conditions => {:subject => "copy issue status"})
                   assert copied_issue
                   assert copied_issue.status
                   assert_equal "Closed", copied_issue.status.name
                 end
                 should "change the new issues to use the copied version" do
                   User.current = User.find(1)
                   assigned_version = Version.generate!(:name => "Assigned Issues", :status => 'open')
                   @source_project.versions << assigned_version
                   assert_equal 3, @source_project.versions.size
                   Issue.generate_for_project!(@source_project,
                                               :fixed_version_id => assigned_version.id,
                                               :subject => "change the new issues to use the copied version",
                                               :tracker_id => 1,
                                               :project_id => @source_project.id)
                   assert @project.copy(@source_project)
                   @project.reload
                   copied_issue = @project.issues.first(:conditions => {:subject => "change the new issues to use the copied version"})
                   assert copied_issue
                   assert copied_issue.fixed_version
                   assert_equal "Assigned Issues", copied_issue.fixed_version.name # Same name
                   assert_not_equal assigned_version.id, copied_issue.fixed_version.id # Different record
                 end
                 should "copy issue relations" do
                   Setting.cross_project_issue_relations = '1'
                   second_issue = Issue.generate!(:status_id => 5,
                                                  :subject => "copy issue relation",
                                                  :tracker_id => 1,
                                                  :assigned_to_id => 2,
                                                  :project_id => @source_project.id)
                   source_relation = IssueRelation.generate!(:issue_from => Issue.find(4),
                                                             :issue_to => second_issue,
                                                             :relation_type => "relates")
                   source_relation_cross_project = IssueRelation.generate!(:issue_from => Issue.find(1),
                                                                           :issue_to => second_issue,
                                                                           :relation_type => "duplicates")
                   assert @project.copy(@source_project)
                   assert_equal @source_project.issues.count, @project.issues.count
                   copied_issue = @project.issues.find_by_subject("Issue on project 2") # Was #4
                   copied_second_issue = @project.issues.find_by_subject("copy issue relation")
                   # First issue with a relation on project
                   assert_equal 1, copied_issue.relations.size, "Relation not copied"
                   copied_relation = copied_issue.relations.first
                   assert_equal "relates", copied_relation.relation_type
                   assert_equal copied_second_issue.id, copied_relation.issue_to_id
                   assert_not_equal source_relation.id, copied_relation.id
                   # Second issue with a cross project relation
                   assert_equal 2, copied_second_issue.relations.size, "Relation not copied"
                   copied_relation = copied_second_issue.relations.select {|r| r.relation_type == 'duplicates'}.first
                   assert_equal "duplicates", copied_relation.relation_type
                   assert_equal 1, copied_relation.issue_from_id, "Cross project relation not kept"
                   assert_not_equal source_relation_cross_project.id, copied_relation.id
                 end
                 should "copy memberships" do
                   assert @project.valid?
                   assert @project.members.empty?
                   assert @project.copy(@source_project)
                   assert_equal @source_project.memberships.size, @project.memberships.size
                   @project.memberships.each do |membership|
                     assert membership
                     assert_equal @project, membership.project
                   end
                 end
                 should "copy memberships with groups and additional roles" do
                   group = Group.create!(:lastname => "Copy group")
                   user = User.find(7)
                   group.users << user
                   # group role
                   Member.create!(:project_id => @source_project.id, :principal => group, :role_ids => [2])
                   member = Member.find_by_user_id_and_project_id(user.id, @source_project.id)
                   # additional role
                   member.role_ids = [1]
                   assert @project.copy(@source_project)
                   member = Member.find_by_user_id_and_project_id(user.id, @project.id)
                   assert_not_nil member
                   assert_equal [1, 2], member.role_ids.sort
                 end
                 should "copy project specific queries" do
                   assert @project.valid?
                   assert @project.queries.empty?
                   assert @project.copy(@source_project)
                   assert_equal @source_project.queries.size, @project.queries.size
                   @project.queries.each do |query|
                     assert query
                     assert_equal @project, query.project
                   end
                   assert_equal @source_project.queries.map(&:user_id).sort, @project.queries.map(&:user_id).sort
                 end
                 should "copy versions" do
                   @source_project.versions << Version.generate!
                   @source_project.versions << Version.generate!
                   assert @project.versions.empty?
                   assert @project.copy(@source_project)
                   assert_equal @source_project.versions.size, @project.versions.size
                   @project.versions.each do |version|
                     assert version
                     assert_equal @project, version.project
                   end
                 end
                 should "copy wiki" do
                   assert_difference 'Wiki.count' do
                     assert @project.copy(@source_project)
                   end
                   assert @project.wiki
                   assert_not_equal @source_project.wiki, @project.wiki
                   assert_equal "Start page", @project.wiki.start_page
                 end
                 should "copy wiki pages and content with hierarchy" do
                   assert_difference 'WikiPage.count', @source_project.wiki.pages.size do
                     assert @project.copy(@source_project)
                   end
                   assert @project.wiki
                   assert_equal @source_project.wiki.pages.size, @project.wiki.pages.size
                   @project.wiki.pages.each do |wiki_page|
                     assert wiki_page.content
                     assert !@source_project.wiki.pages.include?(wiki_page)
                   end
                   parent = @project.wiki.find_page('Parent_page')
                   child1 = @project.wiki.find_page('Child_page_1')
                   child2 = @project.wiki.find_page('Child_page_2')
                   assert_equal parent, child1.parent
                   assert_equal parent, child2.parent
                 end
                 should "copy issue categories" do
                   assert @project.copy(@source_project)
                   assert_equal 2, @project.issue_categories.size
                   @project.issue_categories.each do |issue_category|
                     assert !@source_project.issue_categories.include?(issue_category)
                   end
                 end
                 should "copy boards" do
                   assert @project.copy(@source_project)
                   assert_equal 1, @project.boards.size
                   @project.boards.each do |board|
                     assert !@source_project.boards.include?(board)
                   end
                 end
                 should "change the new issues to use the copied issue categories" do
                   issue = Issue.find(4)
                   issue.update_attribute(:category_id, 3)
                   assert @project.copy(@source_project)
                   @project.issues.each do |issue|
                     assert issue.category
                     assert_equal "Stock management", issue.category.name # Same name
                     assert_not_equal IssueCategory.find(3), issue.category # Different record
                   end
                 end
                 should "limit copy with :only option" do
                   assert @project.members.empty?
                   assert @project.issue_categories.empty?
                   assert @source_project.issues.any?
                   assert @project.copy(@source_project, :only => ['members', 'issue_categories'])
                   assert @project.members.any?
                   assert @project.issue_categories.any?
                   assert @project.issues.empty?
                 end
               end
               context "#start_date" do
                 setup do
                   ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                   @project = Project.generate!(:identifier => 'test0')
                   @project.trackers << Tracker.generate!
                 end
                 should "be nil if there are no issues on the project" do
                   assert_nil @project.start_date
                 end
                 should "be tested when issues have no start date"
                 should "be the earliest start date of it's issues" do
                   early = 7.days.ago.to_date
                   Issue.generate_for_project!(@project, :start_date => Date.today)
                   Issue.generate_for_project!(@project, :start_date => early)
                   assert_equal early, @project.start_date
                 end
               end
               context "#due_date" do
                 setup do
                   ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                   @project = Project.generate!(:identifier => 'test0')
                   @project.trackers << Tracker.generate!
                 end
                 should "be nil if there are no issues on the project" do
                   assert_nil @project.due_date
                 end
                 should "be tested when issues have no due date"
                 should "be the latest due date of it's issues" do
                   future = 7.days.from_now.to_date
                   Issue.generate_for_project!(@project, :due_date => future)
                   Issue.generate_for_project!(@project, :due_date => Date.today)
                   assert_equal future, @project.due_date
                 end
                 should "be the latest due date of it's versions" do
                   future = 7.days.from_now.to_date
                   @project.versions << Version.generate!(:effective_date => future)
                   @project.versions << Version.generate!(:effective_date => Date.today)
                   assert_equal future, @project.due_date
                 end
                 should "pick the latest date from it's issues and versions" do
                   future = 7.days.from_now.to_date
                   far_future = 14.days.from_now.to_date
                   Issue.generate_for_project!(@project, :due_date => far_future)
                   @project.versions << Version.generate!(:effective_date => future)
                   assert_equal far_future, @project.due_date
                 end
               end
               context "Project#completed_percent" do
                 setup do
                   ProjectCustomField.destroy_all # Custom values are a mess to isolate in tests
                   @project = Project.generate!(:identifier => 'test0')
                   @project.trackers << Tracker.generate!
                 end
                 context "no versions" do
                   should "be 100" do
                     assert_equal 100, @project.completed_percent
                   end
                 end
                 context "with versions" do
                   should "return 0 if the versions have no issues" do
                     Version.generate!(:project => @project)
                     Version.generate!(:project => @project)
                     assert_equal 0, @project.completed_percent
                   end
                   should "return 100 if the version has only closed issues" do
                     v1 = Version.generate!(:project => @project)
                     Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
                     v2 = Version.generate!(:project => @project)
                     Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
                     assert_equal 100, @project.completed_percent
                   end
                   should "return the averaged completed percent of the versions (not weighted)" do
                     v1 = Version.generate!(:project => @project)
                     Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
                     v2 = Version.generate!(:project => @project)
                     Issue.generate_for_project!(@project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
                     assert_equal 50, @project.completed_percent
                   end
                 end
               end
               context "#notified_users" do
                 setup do
                   @project = Project.generate!
                   @role = Role.generate!
                   @user_with_membership_notification = User.generate!(:mail_notification => 'selected')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @user_with_membership_notification, :mail_notification => true)
                   @all_events_user = User.generate!(:mail_notification => 'all')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @all_events_user)
                   @no_events_user = User.generate!(:mail_notification => 'none')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @no_events_user)
                   @only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @only_my_events_user)
                   @only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @only_assigned_user)
                   @only_owned_user = User.generate!(:mail_notification => 'only_owner')
                   Member.generate!(:project => @project, :roles => [@role], :principal => @only_owned_user)
                 end
                 should "include members with a mail notification" do
                   assert @project.notified_users.include?(@user_with_membership_notification)
                 end
                 should "include users with the 'all' notification option" do
                   assert @project.notified_users.include?(@all_events_user)
                 end
                 should "not include users with the 'none' notification option" do
                   assert !@project.notified_users.include?(@no_events_user)
                 end
                 should "not include users with the 'only_my_events' notification option" do
                   assert !@project.notified_users.include?(@only_my_events_user)
                 end
                 should "not include users with the 'only_assigned' notification option" do
                   assert !@project.notified_users.include?(@only_assigned_user)
                 end
                 should "not include users with the 'only_owner' notification option" do
                   assert !@project.notified_users.include?(@only_owned_user)
                 end
               end
             end