jro_apps/redmine Commit - r12222:d020a06c5ce0

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

:versions,

33

:versions,

34

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

34

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

35

:groups_users,

35

:groups_users,

36

:boards, :messages,

36

:boards, :messages,

37

:repositories,

37

:repositories,

38

:news, :comments,

38

:news, :comments,

39

:documents

39

:documents

40

41

def setup

41

def setup

42

@ecookbook = Project.find(1)

42

@ecookbook = Project.find(1)

43

@ecookbook_sub1 = Project.find(3)

43

@ecookbook_sub1 = Project.find(3)

44

set_tmp_attachments_directory

44

set_tmp_attachments_directory

45

User.current = nil

45

User.current = nil

46

end

46

end

47

48

def test_truth

48

def test_truth

49

assert_kind_of Project, @ecookbook

49

assert_kind_of Project, @ecookbook

50

assert_equal "eCookbook", @ecookbook.name

50

assert_equal "eCookbook", @ecookbook.name

51

end

51

end

52

53

def test_default_attributes

53

def test_default_attributes

54

with_settings :default_projects_public => '1' do

54

with_settings :default_projects_public => '1' do

55

assert_equal true, Project.new.is_public

55

assert_equal true, Project.new.is_public

56

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

56

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

57

end

57

end

58

59

with_settings :default_projects_public => '0' do

59

with_settings :default_projects_public => '0' do

60

assert_equal false, Project.new.is_public

60

assert_equal false, Project.new.is_public

61

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

61

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

62

end

62

end

63

64

with_settings :sequential_project_identifiers => '1' do

64

with_settings :sequential_project_identifiers => '1' do

65

assert !Project.new.identifier.blank?

65

assert !Project.new.identifier.blank?

66

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

66

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

67

end

67

end

68

69

with_settings :sequential_project_identifiers => '0' do

69

with_settings :sequential_project_identifiers => '0' do

70

assert Project.new.identifier.blank?

70

assert Project.new.identifier.blank?

71

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

71

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

72

end

72

end

73

74

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

74

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

75

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

75

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

76

end

76

end

77

end

77

end

78

79

def test_default_trackers_should_match_default_tracker_ids_setting

79

def test_default_trackers_should_match_default_tracker_ids_setting

80

with_settings :default_projects_tracker_ids => ['1', '3'] do

80

with_settings :default_projects_tracker_ids => ['1', '3'] do

81

assert_equal Tracker.find(1, 3).sort, Project.new.trackers.sort

81

assert_equal Tracker.find(1, 3).sort, Project.new.trackers.sort

82

end

82

end

83

end

83

end

84

85

def test_default_trackers_should_be_all_trackers_with_blank_setting

85

def test_default_trackers_should_be_all_trackers_with_blank_setting

86

with_settings :default_projects_tracker_ids => nil do

86

with_settings :default_projects_tracker_ids => nil do

87

assert_equal Tracker.all.sort, Project.new.trackers.sort

87

assert_equal Tracker.all.sort, Project.new.trackers.sort

88

end

88

end

89

end

89

end

90

91

def test_default_trackers_should_be_empty_with_empty_setting

91

def test_default_trackers_should_be_empty_with_empty_setting

92

with_settings :default_projects_tracker_ids => [] do

92

with_settings :default_projects_tracker_ids => [] do

93

assert_equal [], Project.new.trackers

93

assert_equal [], Project.new.trackers

94

end

94

end

95

end

95

end

96

97

def test_default_trackers_should_not_replace_initialized_trackers

97

def test_default_trackers_should_not_replace_initialized_trackers

98

with_settings :default_projects_tracker_ids => ['1', '3'] do

98

with_settings :default_projects_tracker_ids => ['1', '3'] do

99

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

99

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

100

end

100

end

101

end

101

end

102

103

def test_update

103

def test_update

104

assert_equal "eCookbook", @ecookbook.name

104

assert_equal "eCookbook", @ecookbook.name

105

@ecookbook.name = "eCook"

105

@ecookbook.name = "eCook"

106

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

106

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

107

@ecookbook.reload

107

@ecookbook.reload

108

assert_equal "eCook", @ecookbook.name

108

assert_equal "eCook", @ecookbook.name

109

end

109

end

110

111

def test_validate_identifier

111

def test_validate_identifier

112

to_test = {"abc" => true,

112

to_test = {"abc" => true,

113

"ab12" => true,

113

"ab12" => true,

114

"ab-12" => true,

114

"ab-12" => true,

115

"ab_12" => true,

115

"ab_12" => true,

116

"12" => false,

116

"12" => false,

117

"new" => false}

117

"new" => false}

118

119

to_test.each do |identifier, valid|

119

to_test.each do |identifier, valid|

120

p = Project.new

120

p = Project.new

121

p.identifier = identifier

121

p.identifier = identifier

122

p.valid?

122

p.valid?

123

if valid

123

if valid

124

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

124

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

125

else

125

else

126

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

126

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

127

end

127

end

128

end

128

end

129

end

129

end

130

131

def test_identifier_should_not_be_frozen_for_a_new_project

131

def test_identifier_should_not_be_frozen_for_a_new_project

132

assert_equal false, Project.new.identifier_frozen?

132

assert_equal false, Project.new.identifier_frozen?

133

end

133

end

134

135

def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier

135

def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier

136

Project.update_all(["identifier = ''"], "id = 1")

136

Project.update_all(["identifier = ''"], "id = 1")

137

138

assert_equal false, Project.find(1).identifier_frozen?

138

assert_equal false, Project.find(1).identifier_frozen?

139

end

139

end

140

141

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

141

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

142

assert_equal true, Project.find(1).identifier_frozen?

142

assert_equal true, Project.find(1).identifier_frozen?

143

end

143

end

144

145

def test_members_should_be_active_users

145

def test_members_should_be_active_users

146

Project.all.each do |project|

146

Project.all.each do |project|

147

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

147

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

148

end

148

end

149

end

149

end

150

151

def test_users_should_be_active_users

151

def test_users_should_be_active_users

152

Project.all.each do |project|

152

Project.all.each do |project|

153

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

153

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

154

end

154

end

155

end

155

end

156

157

def test_open_scope_on_issues_association

157

def test_open_scope_on_issues_association

158

assert_kind_of Issue, Project.find(1).issues.open.first

158

assert_kind_of Issue, Project.find(1).issues.open.first

159

end

159

end

160

161

def test_archive

161

def test_archive

162

user = @ecookbook.members.first.user

162

user = @ecookbook.members.first.user

163

@ecookbook.archive

163

@ecookbook.archive

164

@ecookbook.reload

164

@ecookbook.reload

165

166

assert !@ecookbook.active?

166

assert !@ecookbook.active?

167

assert @ecookbook.archived?

167

assert @ecookbook.archived?

168

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

168

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

169

# Subproject are also archived

169

# Subproject are also archived

170

assert !@ecookbook.children.empty?

170

assert !@ecookbook.children.empty?

171

assert @ecookbook.descendants.active.empty?

171

assert @ecookbook.descendants.active.empty?

172

end

172

end

173

174

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

174

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

175

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

175

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

176

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

176

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

177

178

assert_no_difference "Project.where(:status => Project::STATUS_ARCHIVED).count" do

178

assert_no_difference "Project.where(:status => Project::STATUS_ARCHIVED).count" do

179

assert_equal false, @ecookbook.archive

179

assert_equal false, @ecookbook.archive

180

end

180

end

181

@ecookbook.reload

181

@ecookbook.reload

182

assert @ecookbook.active?

182

assert @ecookbook.active?

183

end

183

end

184

185

def test_unarchive

185

def test_unarchive

186

user = @ecookbook.members.first.user

186

user = @ecookbook.members.first.user

187

@ecookbook.archive

187

@ecookbook.archive

188

# A subproject of an archived project can not be unarchived

188

# A subproject of an archived project can not be unarchived

189

assert !@ecookbook_sub1.unarchive

189

assert !@ecookbook_sub1.unarchive

190

191

# Unarchive project

191

# Unarchive project

192

assert @ecookbook.unarchive

192

assert @ecookbook.unarchive

193

@ecookbook.reload

193

@ecookbook.reload

194

assert @ecookbook.active?

194

assert @ecookbook.active?

195

assert !@ecookbook.archived?

195

assert !@ecookbook.archived?

196

assert user.projects.include?(@ecookbook)

196

assert user.projects.include?(@ecookbook)

197

# Subproject can now be unarchived

197

# Subproject can now be unarchived

198

@ecookbook_sub1.reload

198

@ecookbook_sub1.reload

199

assert @ecookbook_sub1.unarchive

199

assert @ecookbook_sub1.unarchive

200

end

200

end

201

202

def test_destroy

202

def test_destroy

203

# 2 active members

203

# 2 active members

204

assert_equal 2, @ecookbook.members.size

204

assert_equal 2, @ecookbook.members.size

205

# and 1 is locked

205

# and 1 is locked

206

assert_equal 3, Member.where('project_id = ?', @ecookbook.id).all.size

206

assert_equal 3, Member.where('project_id = ?', @ecookbook.id).all.size

207

# some boards

207

# some boards

208

assert @ecookbook.boards.any?

208

assert @ecookbook.boards.any?

209

210

@ecookbook.destroy

210

@ecookbook.destroy

211

# make sure that the project non longer exists

211

# make sure that the project non longer exists

212

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

212

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

213

# make sure related data was removed

213

# make sure related data was removed

214

assert_nil Member.where(:project_id => @ecookbook.id).first

214

assert_nil Member.where(:project_id => @ecookbook.id).first

215

assert_nil Board.where(:project_id => @ecookbook.id).first

215

assert_nil Board.where(:project_id => @ecookbook.id).first

216

assert_nil Issue.where(:project_id => @ecookbook.id).first

216

assert_nil Issue.where(:project_id => @ecookbook.id).first

217

end

217

end

218

219

def test_destroy_should_destroy_subtasks

219

def test_destroy_should_destroy_subtasks

220

issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}

220

issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}

221

issues[0].update_attribute :parent_issue_id, issues[1].id

221

issues[0].update_attribute :parent_issue_id, issues[1].id

222

issues[2].update_attribute :parent_issue_id, issues[1].id

222

issues[2].update_attribute :parent_issue_id, issues[1].id

223

assert_equal 2, issues[1].children.count

223

assert_equal 2, issues[1].children.count

224

225

assert_nothing_raised do

225

assert_nothing_raised do

226

Project.find(1).destroy

226

Project.find(1).destroy

227

end

227

end

228

assert Issue.find_all_by_id(issues.map(&:id)).empty?

228

assert Issue.find_all_by_id(issues.map(&:id)).empty?

229

end

229

end

230

231

def test_destroying_root_projects_should_clear_data

231

def test_destroying_root_projects_should_clear_data

232

Project.roots.each do |root|

232

Project.roots.each do |root|

233

root.destroy

233

root.destroy

234

end

234

end

235

236

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

236

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

237

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

237

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

238

assert_equal 0, MemberRole.count

238

assert_equal 0, MemberRole.count

239

assert_equal 0, Issue.count

239

assert_equal 0, Issue.count

240

assert_equal 0, Journal.count

240

assert_equal 0, Journal.count

241

assert_equal 0, JournalDetail.count

241

assert_equal 0, JournalDetail.count

242

assert_equal 0, Attachment.count, "Attachments were not deleted: #{Attachment.all.inspect}"

242

assert_equal 0, Attachment.count, "Attachments were not deleted: #{Attachment.all.inspect}"

243

assert_equal 0, EnabledModule.count

243

assert_equal 0, EnabledModule.count

244

assert_equal 0, IssueCategory.count

244

assert_equal 0, IssueCategory.count

245

assert_equal 0, IssueRelation.count

245

assert_equal 0, IssueRelation.count

246

assert_equal 0, Board.count

246

assert_equal 0, Board.count

247

assert_equal 0, Message.count

247

assert_equal 0, Message.count

248

assert_equal 0, News.count

248

assert_equal 0, News.count

249

assert_equal 0, Query.where("project_id IS NOT NULL").count

249

assert_equal 0, Query.where("project_id IS NOT NULL").count

250

assert_equal 0, Repository.count

250

assert_equal 0, Repository.count

251

assert_equal 0, Changeset.count

251

assert_equal 0, Changeset.count

252

assert_equal 0, Change.count

252

assert_equal 0, Change.count

253

assert_equal 0, Comment.count

253

assert_equal 0, Comment.count

254

assert_equal 0, TimeEntry.count

254

assert_equal 0, TimeEntry.count

255

assert_equal 0, Version.count

255

assert_equal 0, Version.count

256

assert_equal 0, Watcher.count

256

assert_equal 0, Watcher.count

257

assert_equal 0, Wiki.count

257

assert_equal 0, Wiki.count

258

assert_equal 0, WikiPage.count

258

assert_equal 0, WikiPage.count

259

assert_equal 0, WikiContent.count

259

assert_equal 0, WikiContent.count

260

assert_equal 0, WikiContent::Version.count

260

assert_equal 0, WikiContent::Version.count

261

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

261

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

262

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

262

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

263

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

263

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

264

end

264

end

265

266

def test_destroy_should_delete_time_entries_custom_values

266

def test_destroy_should_delete_time_entries_custom_values

267

project = Project.generate!

267

project = Project.generate!

268

time_entry = TimeEntry.generate!(:project => project, :custom_field_values => {10 => '1'})

268

time_entry = TimeEntry.generate!(:project => project, :custom_field_values => {10 => '1'})

269

270

assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do

270

assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do

271

assert project.destroy

271

assert project.destroy

272

end

272

end

273

end

273

end

274

275

def test_move_an_orphan_project_to_a_root_project

275

def test_move_an_orphan_project_to_a_root_project

276

sub = Project.find(2)

276

sub = Project.find(2)

277

sub.set_parent! @ecookbook

277

sub.set_parent! @ecookbook

278

assert_equal @ecookbook.id, sub.parent.id

278

assert_equal @ecookbook.id, sub.parent.id

279

@ecookbook.reload

279

@ecookbook.reload

280

assert_equal 4, @ecookbook.children.size

280

assert_equal 4, @ecookbook.children.size

281

end

281

end

282

283

def test_move_an_orphan_project_to_a_subproject

283

def test_move_an_orphan_project_to_a_subproject

284

sub = Project.find(2)

284

sub = Project.find(2)

285

assert sub.set_parent!(@ecookbook_sub1)

285

assert sub.set_parent!(@ecookbook_sub1)

286

end

286

end

287

288

def test_move_a_root_project_to_a_project

288

def test_move_a_root_project_to_a_project

289

sub = @ecookbook

289

sub = @ecookbook

290

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

290

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

291

end

291

end

292

293

def test_should_not_move_a_project_to_its_children

293

def test_should_not_move_a_project_to_its_children

294

sub = @ecookbook

294

sub = @ecookbook

295

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

295

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

296

end

296

end

297

298

def test_set_parent_should_add_roots_in_alphabetical_order

298

def test_set_parent_should_add_roots_in_alphabetical_order

299

ProjectCustomField.delete_all

299

ProjectCustomField.delete_all

300

Project.delete_all

300

Project.delete_all

301

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

301

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

302

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

302

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

303

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

303

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

304

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

304

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

305

306

assert_equal 4, Project.count

306

assert_equal 4, Project.count

307

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

307

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

308

end

308

end

309

310

def test_set_parent_should_add_children_in_alphabetical_order

310

def test_set_parent_should_add_children_in_alphabetical_order

311

ProjectCustomField.delete_all

311

ProjectCustomField.delete_all

312

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

312

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

313

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

313

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

314

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

314

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

315

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

315

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

316

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

316

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

317

318

parent.reload

318

parent.reload

319

assert_equal 4, parent.children.size

319

assert_equal 4, parent.children.size

320

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

320

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

321

end

321

end

322

323

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

323

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

324

# Parent issue with a hierarchy project's fixed version

324

# Parent issue with a hierarchy project's fixed version

325

parent_issue = Issue.find(1)

325

parent_issue = Issue.find(1)

326

parent_issue.update_attribute(:fixed_version_id, 4)

326

parent_issue.update_attribute(:fixed_version_id, 4)

327

parent_issue.reload

327

parent_issue.reload

328

assert_equal 4, parent_issue.fixed_version_id

328

assert_equal 4, parent_issue.fixed_version_id

329

330

# Should keep fixed versions for the issues

330

# Should keep fixed versions for the issues

331

issue_with_local_fixed_version = Issue.find(5)

331

issue_with_local_fixed_version = Issue.find(5)

332

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

332

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

333

issue_with_local_fixed_version.reload

333

issue_with_local_fixed_version.reload

334

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

334

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

335

336

# Local issue with hierarchy fixed_version

336

# Local issue with hierarchy fixed_version

337

issue_with_hierarchy_fixed_version = Issue.find(13)

337

issue_with_hierarchy_fixed_version = Issue.find(13)

338

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

338

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

339

issue_with_hierarchy_fixed_version.reload

339

issue_with_hierarchy_fixed_version.reload

340

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

340

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

341

342

# Move project out of the issue's hierarchy

342

# Move project out of the issue's hierarchy

343

moved_project = Project.find(3)

343

moved_project = Project.find(3)

344

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

344

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

345

parent_issue.reload

345

parent_issue.reload

346

issue_with_local_fixed_version.reload

346

issue_with_local_fixed_version.reload

347

issue_with_hierarchy_fixed_version.reload

347

issue_with_hierarchy_fixed_version.reload

348

349

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

349

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

350

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"

350

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"

351

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

351

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

352

end

352

end

353

354

def test_parent

354

def test_parent

355

p = Project.find(6).parent

355

p = Project.find(6).parent

356

assert p.is_a?(Project)

356

assert p.is_a?(Project)

357

assert_equal 5, p.id

357

assert_equal 5, p.id

358

end

358

end

359

360

def test_ancestors

360

def test_ancestors

361

a = Project.find(6).ancestors

361

a = Project.find(6).ancestors

362

assert a.first.is_a?(Project)

362

assert a.first.is_a?(Project)

363

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

363

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

364

end

364

end

365

366

def test_root

366

def test_root

367

r = Project.find(6).root

367

r = Project.find(6).root

368

assert r.is_a?(Project)

368

assert r.is_a?(Project)

369

assert_equal 1, r.id

369

assert_equal 1, r.id

370

end

370

end

371

372

def test_children

372

def test_children

373

c = Project.find(1).children

373

c = Project.find(1).children

374

assert c.first.is_a?(Project)

374

assert c.first.is_a?(Project)

375

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

375

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

376

end

376

end

377

378

def test_descendants

378

def test_descendants

379

d = Project.find(1).descendants

379

d = Project.find(1).descendants

380

assert d.first.is_a?(Project)

380

assert d.first.is_a?(Project)

381

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

381

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

382

end

382

end

383

384

def test_allowed_parents_should_be_empty_for_non_member_user

384

def test_allowed_parents_should_be_empty_for_non_member_user

385

Role.non_member.add_permission!(:add_project)

385

Role.non_member.add_permission!(:add_project)

386

user = User.find(9)

386

user = User.find(9)

387

assert user.memberships.empty?

387

assert user.memberships.empty?

388

User.current = user

388

User.current = user

389

assert Project.new.allowed_parents.compact.empty?

389

assert Project.new.allowed_parents.compact.empty?

390

end

390

end

391

392

def test_allowed_parents_with_add_subprojects_permission

392

def test_allowed_parents_with_add_subprojects_permission

393

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

393

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

394

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

394

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

395

User.current = User.find(2)

395

User.current = User.find(2)

396

# new project

396

# new project

397

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

397

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

398

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

398

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

399

# existing root project

399

# existing root project

400

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

400

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

401

# existing child

401

# existing child

402

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

402

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

403

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

403

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

404

end

404

end

405

406

def test_allowed_parents_with_add_project_permission

406

def test_allowed_parents_with_add_project_permission

407

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

407

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

408

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

408

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

409

User.current = User.find(2)

409

User.current = User.find(2)

410

# new project

410

# new project

411

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

411

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

412

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

412

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

413

# existing root project

413

# existing root project

414

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

414

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

415

# existing child

415

# existing child

416

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

416

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

417

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

417

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

418

end

418

end

419

420

def test_allowed_parents_with_add_project_and_subprojects_permission

420

def test_allowed_parents_with_add_project_and_subprojects_permission

421

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

421

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

422

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

422

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

423

User.current = User.find(2)

423

User.current = User.find(2)

424

# new project

424

# new project

425

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

425

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

426

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

426

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

427

# existing root project

427

# existing root project

428

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

428

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

429

# existing child

429

# existing child

430

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

430

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

431

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

431

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

432

end

432

end

433

434

def test_users_by_role

434

def test_users_by_role

435

users_by_role = Project.find(1).users_by_role

435

users_by_role = Project.find(1).users_by_role

436

assert_kind_of Hash, users_by_role

436

assert_kind_of Hash, users_by_role

437

role = Role.find(1)

437

role = Role.find(1)

438

assert_kind_of Array, users_by_role[role]

438

assert_kind_of Array, users_by_role[role]

439

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

439

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

440

end

440

end

441

442

def test_rolled_up_trackers

442

def test_rolled_up_trackers

443

parent = Project.find(1)

443

parent = Project.find(1)

444

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

444

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

445

child = parent.children.find(3)

445

child = parent.children.find(3)

446

447

assert_equal [1, 2], parent.tracker_ids

447

assert_equal [1, 2], parent.tracker_ids

448

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

448

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

449

450

assert_kind_of Tracker, parent.rolled_up_trackers.first

450

assert_kind_of Tracker, parent.rolled_up_trackers.first

451

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

451

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

452

453

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

453

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

454

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

454

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

455

end

455

end

456

457

def test_rolled_up_trackers_should_ignore_archived_subprojects

457

def test_rolled_up_trackers_should_ignore_archived_subprojects

458

parent = Project.find(1)

458

parent = Project.find(1)

459

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

459

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

460

child = parent.children.find(3)

460

child = parent.children.find(3)

461

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

461

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

462

parent.children.each(&:archive)

462

parent.children.each(&:archive)

463

464

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

464

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

465

end

465

end

466

467

test "#rolled_up_trackers should ignore projects with issue_tracking module disabled" do

467

test "#rolled_up_trackers should ignore projects with issue_tracking module disabled" do

468

parent = Project.generate!

468

parent = Project.generate!

469

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

469

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

470

child = Project.generate_with_parent!(parent)

470

child = Project.generate_with_parent!(parent)

471

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

471

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

472

473

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

473

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

474

475

assert child.disable_module!(:issue_tracking)

475

assert child.disable_module!(:issue_tracking)

476

parent.reload

476

parent.reload

477

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

477

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

478

end

478

end

479

480

test "#rolled_up_versions should include the versions for the current project" do

480

test "#rolled_up_versions should include the versions for the current project" do

481

project = Project.generate!

481

project = Project.generate!

482

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

482

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

483

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

483

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

484

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

484

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

485

end

485

end

486

487

test "#rolled_up_versions should include versions for a subproject" do

487

test "#rolled_up_versions should include versions for a subproject" do

488

project = Project.generate!

488

project = Project.generate!

489

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

489

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

490

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

490

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

491

subproject = Project.generate_with_parent!(project)

491

subproject = Project.generate_with_parent!(project)

492

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

492

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

493

494

assert_same_elements [

494

assert_same_elements [

495

parent_version_1,

495

parent_version_1,

496

parent_version_2,

496

parent_version_2,

497

subproject_version

497

subproject_version

498

], project.rolled_up_versions

498

], project.rolled_up_versions

499

end

499

end

500

501

test "#rolled_up_versions should include versions for a sub-subproject" do

501

test "#rolled_up_versions should include versions for a sub-subproject" do

502

project = Project.generate!

502

project = Project.generate!

503

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

503

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

504

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

504

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

505

subproject = Project.generate_with_parent!(project)

505

subproject = Project.generate_with_parent!(project)

506

sub_subproject = Project.generate_with_parent!(subproject)

506

sub_subproject = Project.generate_with_parent!(subproject)

507

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

507

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

508

project.reload

508

project.reload

509

510

assert_same_elements [

510

assert_same_elements [

511

parent_version_1,

511

parent_version_1,

512

parent_version_2,

512

parent_version_2,

513

sub_subproject_version

513

sub_subproject_version

514

], project.rolled_up_versions

514

], project.rolled_up_versions

515

end

515

end

516

517

test "#rolled_up_versions should only check active projects" do

517

test "#rolled_up_versions should only check active projects" do

518

project = Project.generate!

518

project = Project.generate!

519

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

519

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

520

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

520

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

521

subproject = Project.generate_with_parent!(project)

521

subproject = Project.generate_with_parent!(project)

522

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

522

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

523

assert subproject.archive

523

assert subproject.archive

524

project.reload

524

project.reload

525

526

assert !subproject.active?

526

assert !subproject.active?

527

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

527

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

528

end

528

end

529

530

def test_shared_versions_none_sharing

530

def test_shared_versions_none_sharing

531

p = Project.find(5)

531

p = Project.find(5)

532

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

532

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

533

assert p.shared_versions.include?(v)

533

assert p.shared_versions.include?(v)

534

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

534

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

535

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

535

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

536

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

536

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

537

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

537

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

538

end

538

end

539

540

def test_shared_versions_descendants_sharing

540

def test_shared_versions_descendants_sharing

541

p = Project.find(5)

541

p = Project.find(5)

542

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

542

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

543

assert p.shared_versions.include?(v)

543

assert p.shared_versions.include?(v)

544

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

544

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

545

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

545

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

546

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

546

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

547

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

547

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

548

end

548

end

549

550

def test_shared_versions_hierarchy_sharing

550

def test_shared_versions_hierarchy_sharing

551

p = Project.find(5)

551

p = Project.find(5)

552

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

552

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

553

assert p.shared_versions.include?(v)

553

assert p.shared_versions.include?(v)

554

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

554

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

555

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

555

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

556

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

556

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

557

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

557

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

558

end

558

end

559

560

def test_shared_versions_tree_sharing

560

def test_shared_versions_tree_sharing

561

p = Project.find(5)

561

p = Project.find(5)

562

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

562

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

563

assert p.shared_versions.include?(v)

563

assert p.shared_versions.include?(v)

564

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

564

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

565

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

565

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

566

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

566

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

567

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

567

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

568

end

568

end

569

570

def test_shared_versions_system_sharing

570

def test_shared_versions_system_sharing

571

p = Project.find(5)

571

p = Project.find(5)

572

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

572

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

573

assert p.shared_versions.include?(v)

573

assert p.shared_versions.include?(v)

574

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

574

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

575

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

575

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

576

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

576

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

577

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

577

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

578

end

578

end

579

580

def test_shared_versions

580

def test_shared_versions

581

parent = Project.find(1)

581

parent = Project.find(1)

582

child = parent.children.find(3)

582

child = parent.children.find(3)

583

private_child = parent.children.find(5)

583

private_child = parent.children.find(5)

584

585

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

585

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

586

assert_equal [4], child.version_ids

586

assert_equal [4], child.version_ids

587

assert_equal [6], private_child.version_ids

587

assert_equal [6], private_child.version_ids

588

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

588

assert_equal [7], Version.where(:sharing => 'system').all.collect(&:id)

589

590

assert_equal 6, parent.shared_versions.size

590

assert_equal 6, parent.shared_versions.size

591

parent.shared_versions.each do |version|

591

parent.shared_versions.each do |version|

592

assert_kind_of Version, version

592

assert_kind_of Version, version

593

end

593

end

594

595

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

595

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

596

end

596

end

597

598

def test_shared_versions_should_ignore_archived_subprojects

598

def test_shared_versions_should_ignore_archived_subprojects

599

parent = Project.find(1)

599

parent = Project.find(1)

600

child = parent.children.find(3)

600

child = parent.children.find(3)

601

child.archive

601

child.archive

602

parent.reload

602

parent.reload

603

604

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

604

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

605

assert_equal [4], child.version_ids

605

assert_equal [4], child.version_ids

606

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

606

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

607

end

607

end

608

609

def test_shared_versions_visible_to_user

609

def test_shared_versions_visible_to_user

610

user = User.find(3)

610

user = User.find(3)

611

parent = Project.find(1)

611

parent = Project.find(1)

612

child = parent.children.find(5)

612

child = parent.children.find(5)

613

614

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

614

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

615

assert_equal [6], child.version_ids

615

assert_equal [6], child.version_ids

616

617

versions = parent.shared_versions.visible(user)

617

versions = parent.shared_versions.visible(user)

618

619

assert_equal 4, versions.size

619

assert_equal 4, versions.size

620

versions.each do |version|

620

versions.each do |version|

621

assert_kind_of Version, version

621

assert_kind_of Version, version

622

end

622

end

623

624

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

624

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

625

end

625

end

626

627

def test_shared_versions_for_new_project_should_include_system_shared_versions

627

def test_shared_versions_for_new_project_should_include_system_shared_versions

628

p = Project.find(5)

628

p = Project.find(5)

629

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

629

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

630

631

assert_include v, Project.new.shared_versions

631

assert_include v, Project.new.shared_versions

632

end

632

end

633

634

def test_next_identifier

634

def test_next_identifier

635

ProjectCustomField.delete_all

635

ProjectCustomField.delete_all

636

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

636

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

637

assert_equal 'p2008041', Project.next_identifier

637

assert_equal 'p2008041', Project.next_identifier

638

end

638

end

639

640

def test_next_identifier_first_project

640

def test_next_identifier_first_project

641

Project.delete_all

641

Project.delete_all

642

assert_nil Project.next_identifier

642

assert_nil Project.next_identifier

643

end

643

end

644

645

def test_enabled_module_names

645

def test_enabled_module_names

646

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

646

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

647

project = Project.new

647

project = Project.new

648

649

project.enabled_module_names = %w(issue_tracking news)

649

project.enabled_module_names = %w(issue_tracking news)

650

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

650

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

651

end

651

end

652

end

652

end

653

654

test "enabled_modules should define module by names and preserve ids" do

654

test "enabled_modules should define module by names and preserve ids" do

655

@project = Project.find(1)

655

@project = Project.find(1)

656

# Remove one module

656

# Remove one module

657

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

657

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

658

assert modules.any?

658

assert modules.any?

659

assert_difference 'EnabledModule.count', -1 do

659

assert_difference 'EnabledModule.count', -1 do

660

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

660

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

661

end

661

end

662

@project.reload

662

@project.reload

663

# Ids should be preserved

663

# Ids should be preserved

664

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

664

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

665

end

665

end

666

667

test "enabled_modules should enable a module" do

667

test "enabled_modules should enable a module" do

668

@project = Project.find(1)

668

@project = Project.find(1)

669

@project.enabled_module_names = []

669

@project.enabled_module_names = []

670

@project.reload

670

@project.reload

671

assert_equal [], @project.enabled_module_names

671

assert_equal [], @project.enabled_module_names

672

#with string

672

#with string

673

@project.enable_module!("issue_tracking")

673

@project.enable_module!("issue_tracking")

674

assert_equal ["issue_tracking"], @project.enabled_module_names

674

assert_equal ["issue_tracking"], @project.enabled_module_names

675

#with symbol

675

#with symbol

676

@project.enable_module!(:gantt)

676

@project.enable_module!(:gantt)

677

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

677

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

678

#don't add a module twice

678

#don't add a module twice

679

@project.enable_module!("issue_tracking")

679

@project.enable_module!("issue_tracking")

680

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

680

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

681

end

681

end

682

683

test "enabled_modules should disable a module" do

683

test "enabled_modules should disable a module" do

684

@project = Project.find(1)

684

@project = Project.find(1)

685

#with string

685

#with string

686

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

686

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

687

@project.disable_module!("issue_tracking")

687

@project.disable_module!("issue_tracking")

688

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

688

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

689

#with symbol

689

#with symbol

690

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

690

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

691

@project.disable_module!(:gantt)

691

@project.disable_module!(:gantt)

692

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

692

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

693

#with EnabledModule object

693

#with EnabledModule object

694

first_module = @project.enabled_modules.first

694

first_module = @project.enabled_modules.first

695

@project.disable_module!(first_module)

695

@project.disable_module!(first_module)

696

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

696

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

697

end

697

end

698

699

def test_enabled_module_names_should_not_recreate_enabled_modules

699

def test_enabled_module_names_should_not_recreate_enabled_modules

700

project = Project.find(1)

700

project = Project.find(1)

701

# Remove one module

701

# Remove one module

702

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

702

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

703

assert modules.any?

703

assert modules.any?

704

assert_difference 'EnabledModule.count', -1 do

704

assert_difference 'EnabledModule.count', -1 do

705

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

705

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

706

end

706

end

707

project.reload

707

project.reload

708

# Ids should be preserved

708

# Ids should be preserved

709

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

709

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

710

end

710

end

711

712

def test_copy_from_existing_project

712

def test_copy_from_existing_project

713

source_project = Project.find(1)

713

source_project = Project.find(1)

714

copied_project = Project.copy_from(1)

714

copied_project = Project.copy_from(1)

715

716

assert copied_project

716

assert copied_project

717

# Cleared attributes

717

# Cleared attributes

718

assert copied_project.id.blank?

718

assert copied_project.id.blank?

719

assert copied_project.name.blank?

719

assert copied_project.name.blank?

720

assert copied_project.identifier.blank?

720

assert copied_project.identifier.blank?

721

722

# Duplicated attributes

722

# Duplicated attributes

723

assert_equal source_project.description, copied_project.description

723

assert_equal source_project.description, copied_project.description

724

assert_equal source_project.enabled_modules, copied_project.enabled_modules

724

assert_equal source_project.enabled_modules, copied_project.enabled_modules

725

assert_equal source_project.trackers, copied_project.trackers

725

assert_equal source_project.trackers, copied_project.trackers

726

727

# Default attributes

727

# Default attributes

728

assert_equal 1, copied_project.status

728

assert_equal 1, copied_project.status

729

end

729

end

730

731

def test_activities_should_use_the_system_activities

731

def test_activities_should_use_the_system_activities

732

project = Project.find(1)

732

project = Project.find(1)

733

assert_equal project.activities, TimeEntryActivity.where(:active => true).all

733

assert_equal project.activities, TimeEntryActivity.where(:active => true).all

734

end

734

end

735

736

737

def test_activities_should_use_the_project_specific_activities

737

def test_activities_should_use_the_project_specific_activities

738

project = Project.find(1)

738

project = Project.find(1)

739

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

739

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

740

assert overridden_activity.save!

740

assert overridden_activity.save!

741

742

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

742

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

743

end

743

end

744

745

def test_activities_should_not_include_the_inactive_project_specific_activities

745

def test_activities_should_not_include_the_inactive_project_specific_activities

746

project = Project.find(1)

746

project = Project.find(1)

747

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

747

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

748

assert overridden_activity.save!

748

assert overridden_activity.save!

749

750

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

750

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

751

end

751

end

752

753

def test_activities_should_not_include_project_specific_activities_from_other_projects

753

def test_activities_should_not_include_project_specific_activities_from_other_projects

754

project = Project.find(1)

754

project = Project.find(1)

755

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

755

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

756

assert overridden_activity.save!

756

assert overridden_activity.save!

757

758

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

758

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

759

end

759

end

760

761

def test_activities_should_handle_nils

761

def test_activities_should_handle_nils

762

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

762

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

763

TimeEntryActivity.delete_all

763

TimeEntryActivity.delete_all

764

765

# No activities

765

# No activities

766

project = Project.find(1)

766

project = Project.find(1)

767

assert project.activities.empty?

767

assert project.activities.empty?

768

769

# No system, one overridden

769

# No system, one overridden

770

assert overridden_activity.save!

770

assert overridden_activity.save!

771

project.reload

771

project.reload

772

assert_equal [overridden_activity], project.activities

772

assert_equal [overridden_activity], project.activities

773

end

773

end

774

775

def test_activities_should_override_system_activities_with_project_activities

775

def test_activities_should_override_system_activities_with_project_activities

776

project = Project.find(1)

776

project = Project.find(1)

777

parent_activity = TimeEntryActivity.first

777

parent_activity = TimeEntryActivity.first

778

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

778

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

779

assert overridden_activity.save!

779

assert overridden_activity.save!

780

781

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

781

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

782

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

782

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

783

end

783

end

784

785

def test_activities_should_include_inactive_activities_if_specified

785

def test_activities_should_include_inactive_activities_if_specified

786

project = Project.find(1)

786

project = Project.find(1)

787

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

787

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

788

assert overridden_activity.save!

788

assert overridden_activity.save!

789

790

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

790

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

791

end

791

end

792

793

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

793

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

794

project = Project.find(1)

794

project = Project.find(1)

795

system_activity = TimeEntryActivity.find_by_name('Design')

795

system_activity = TimeEntryActivity.find_by_name('Design')

796

assert system_activity.active?

796

assert system_activity.active?

797

overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)

797

overridden_activity = TimeEntryActivity.create!(:name => "Project", :project => project, :parent => system_activity, :active => false)

798

assert overridden_activity.save!

798

assert overridden_activity.save!

799

800

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

800

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

801

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

801

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

802

end

802

end

803

804

def test_close_completed_versions

804

def test_close_completed_versions

805

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

805

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

806

project = Project.find(1)

806

project = Project.find(1)

807

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

807

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

808

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

808

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

809

project.close_completed_versions

809

project.close_completed_versions

810

project.reload

810

project.reload

811

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

811

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

812

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

812

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

813

end

813

end

814

815

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

815

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

816

project = Project.generate!

816

project = Project.generate!

817

assert_nil project.start_date

817

assert_nil project.start_date

818

end

818

end

819

820

test "#start_date should be nil when issues have no start date" do

820

test "#start_date should be nil when issues have no start date" do

821

project = Project.generate!

821

project = Project.generate!

822

project.trackers << Tracker.generate!

822

project.trackers << Tracker.generate!

823

early = 7.days.ago.to_date

823

early = 7.days.ago.to_date

824

Issue.generate!(:project => project, :start_date => nil)

824

Issue.generate!(:project => project, :start_date => nil)

825

826

assert_nil project.start_date

826

assert_nil project.start_date

827

end

827

end

828

829

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

829

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

830

project = Project.generate!

830

project = Project.generate!

831

project.trackers << Tracker.generate!

831

project.trackers << Tracker.generate!

832

early = 7.days.ago.to_date

832

early = 7.days.ago.to_date

833

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

833

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

834

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

834

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

835

836

assert_equal early, project.start_date

836

assert_equal early, project.start_date

837

end

837

end

838

839

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

839

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

840

project = Project.generate!

840

project = Project.generate!

841

assert_nil project.due_date

841

assert_nil project.due_date

842

end

842

end

843

844

test "#due_date should be nil if there are no issues with due dates" do

844

test "#due_date should be nil if there are no issues with due dates" do

845

project = Project.generate!

845

project = Project.generate!

846

project.trackers << Tracker.generate!

846

project.trackers << Tracker.generate!

847

Issue.generate!(:project => project, :due_date => nil)

847

Issue.generate!(:project => project, :due_date => nil)

848

849

assert_nil project.due_date

849

assert_nil project.due_date

850

end

850

end

851

852

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

852

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

853

project = Project.generate!

853

project = Project.generate!

854

project.trackers << Tracker.generate!

854

project.trackers << Tracker.generate!

855

future = 7.days.from_now.to_date

855

future = 7.days.from_now.to_date

856

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

856

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

857

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

857

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

858

859

assert_equal future, project.due_date

859

assert_equal future, project.due_date

860

end

860

end

861

862

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

862

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

863

project = Project.generate!

863

project = Project.generate!

864

future = 7.days.from_now.to_date

864

future = 7.days.from_now.to_date

865

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

865

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

866

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

866

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

867

868

assert_equal future, project.due_date

868

assert_equal future, project.due_date

869

end

869

end

870

871

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

871

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

872

project = Project.generate!

872

project = Project.generate!

873

project.trackers << Tracker.generate!

873

project.trackers << Tracker.generate!

874

future = 7.days.from_now.to_date

874

future = 7.days.from_now.to_date

875

far_future = 14.days.from_now.to_date

875

far_future = 14.days.from_now.to_date

876

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

876

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

877

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

877

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

878

879

assert_equal far_future, project.due_date

879

assert_equal far_future, project.due_date

880

end

880

end

881

882

test "#completed_percent with no versions should be 100" do

882

test "#completed_percent with no versions should be 100" do

883

project = Project.generate!

883

project = Project.generate!

884

assert_equal 100, project.completed_percent

884

assert_equal 100, project.completed_percent

885

end

885

end

886

887

test "#completed_percent with versions should return 0 if the versions have no issues" do

887

test "#completed_percent with versions should return 0 if the versions have no issues" do

888

project = Project.generate!

888

project = Project.generate!

889

Version.generate!(:project => project)

889

Version.generate!(:project => project)

890

Version.generate!(:project => project)

890

Version.generate!(:project => project)

891

892

assert_equal 0, project.completed_percent

892

assert_equal 0, project.completed_percent

893

end

893

end

894

895

test "#completed_percent with versions should return 100 if the version has only closed issues" do

895

test "#completed_percent with versions should return 100 if the version has only closed issues" do

896

project = Project.generate!

896

project = Project.generate!

897

project.trackers << Tracker.generate!

897

project.trackers << Tracker.generate!

898

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

898

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

899

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

899

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

900

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

900

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

901

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

901

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

902

903

assert_equal 100, project.completed_percent

903

assert_equal 100, project.completed_percent

904

end

904

end

905

906

test "#completed_percent with versions should return the averaged completed percent of the versions (not weighted)" do

906

test "#completed_percent with versions should return the averaged completed percent of the versions (not weighted)" do

907

project = Project.generate!

907

project = Project.generate!

908

project.trackers << Tracker.generate!

908

project.trackers << Tracker.generate!

909

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

909

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

910

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

910

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

911

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

911

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

912

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

912

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

913

914

assert_equal 50, project.completed_percent

914

assert_equal 50, project.completed_percent

915

end

915

end

916

917

test "#notified_users" do

917

test "#notified_users" do

918

project = Project.generate!

918

project = Project.generate!

919

role = Role.generate!

919

role = Role.generate!

920

921

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

921

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

922

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

922

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

923

924

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

924

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

925

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

925

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

926

927

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

927

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

928

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

928

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

929

930

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

930

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

931

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

931

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

932

933

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

933

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

934

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

934

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

935

936

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

936

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

937

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

937

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

938

939

assert project.notified_users.include?(user_with_membership_notification), "should include members with a mail notification"

939

assert project.notified_users.include?(user_with_membership_notification), "should include members with a mail notification"

940

assert project.notified_users.include?(all_events_user), "should include users with the 'all' notification option"

940

assert project.notified_users.include?(all_events_user), "should include users with the 'all' notification option"

941

assert !project.notified_users.include?(no_events_user), "should not include users with the 'none' notification option"

941

assert !project.notified_users.include?(no_events_user), "should not include users with the 'none' notification option"

942

assert !project.notified_users.include?(only_my_events_user), "should not include users with the 'only_my_events' notification option"

942

assert !project.notified_users.include?(only_my_events_user), "should not include users with the 'only_my_events' notification option"

943

assert !project.notified_users.include?(only_assigned_user), "should not include users with the 'only_assigned' notification option"

943

assert !project.notified_users.include?(only_assigned_user), "should not include users with the 'only_assigned' notification option"

944

assert !project.notified_users.include?(only_owned_user), "should not include users with the 'only_owner' notification option"

944

assert !project.notified_users.include?(only_owned_user), "should not include users with the 'only_owner' notification option"

945

end

945

end

946

end

946

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-2013  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,
                        :versions,
                        :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                        :groups_users,
                        :boards, :messages,
                        :repositories,
                        :news, :comments,
                        :documents
               def setup
                 @ecookbook = Project.find(1)
                 @ecookbook_sub1 = Project.find(3)
                 set_tmp_attachments_directory
                 User.current = nil
               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
               end
               def test_default_trackers_should_match_default_tracker_ids_setting
                 with_settings :default_projects_tracker_ids => ['1', '3'] do
                   assert_equal Tracker.find(1, 3).sort, Project.new.trackers.sort
                 end
               end
               def test_default_trackers_should_be_all_trackers_with_blank_setting
                 with_settings :default_projects_tracker_ids => nil do
                   assert_equal Tracker.all.sort, Project.new.trackers.sort
                 end
               end
               def test_default_trackers_should_be_empty_with_empty_setting
                 with_settings :default_projects_tracker_ids => [] do
                   assert_equal [], Project.new.trackers
                 end
               end
               def test_default_trackers_should_not_replace_initialized_trackers
                 with_settings :default_projects_tracker_ids => ['1', '3'] do
                   assert_equal Tracker.find(1, 2).sort, Project.new(:tracker_ids => [1, 2]).trackers.sort
                 end
               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,
                            "ab_12" => true,
                            "12" => false,
                            "new" => false}
                 to_test.each do |identifier, valid|
                   p = Project.new
                   p.identifier = identifier
                   p.valid?
                   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_identifier_should_not_be_frozen_for_a_new_project
                 assert_equal false, Project.new.identifier_frozen?
               end
               def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier
                 Project.update_all(["identifier = ''"], "id = 1")
                 assert_equal false, Project.find(1).identifier_frozen?
               end
               def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier
                 assert_equal true, Project.find(1).identifier_frozen?
               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_open_scope_on_issues_association
                 assert_kind_of Issue, Project.find(1).issues.open.first
               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.where(:status => Project::STATUS_ARCHIVED).count" 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.where('project_id = ?', @ecookbook.id).all.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.where(:project_id => @ecookbook.id).first
                 assert_nil Board.where(:project_id => @ecookbook.id).first
                 assert_nil Issue.where(:project_id => @ecookbook.id).first
               end
               def test_destroy_should_destroy_subtasks
                 issues = (0..2).to_a.map {Issue.create!(:project_id => 1, :tracker_id => 1, :author_id => 1, :subject => 'test')}
                 issues[0].update_attribute :parent_issue_id, issues[1].id
                 issues[2].update_attribute :parent_issue_id, issues[1].id
                 assert_equal 2, issues[1].children.count
                 assert_nothing_raised do
                   Project.find(1).destroy
                 end
                 assert Issue.find_all_by_id(issues.map(&:id)).empty?
               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, "Attachments were not deleted: #{Attachment.all.inspect}"
                 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.where("project_id IS NOT NULL").count
                 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").count
                 assert_equal 0, Project.connection.select_all("SELECT * FROM custom_fields_projects").count
                 assert_equal 0, CustomValue.where(:customized_type => ['Project', 'Issue', 'TimeEntry', 'Version']).count
               end
               def test_destroy_should_delete_time_entries_custom_values
                 project = Project.generate!
                 time_entry = TimeEntry.generate!(:project => project, :custom_field_values => {10 => '1'})
                 assert_difference 'CustomValue.where(:customized_type => "TimeEntry").count', -1 do
                   assert project.destroy
                 end
               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_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
               test "#rolled_up_trackers should ignore projects with issue_tracking module disabled" do
                 parent = Project.generate!
                 parent.trackers = Tracker.find([1, 2])
                 child = Project.generate_with_parent!(parent)
                 child.trackers = Tracker.find([2, 3])
                 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id).sort
                 assert child.disable_module!(:issue_tracking)
                 parent.reload
                 assert_equal [1, 2], parent.rolled_up_trackers.collect(&:id).sort
               end
               test "#rolled_up_versions should include the versions for the current project" do
                 project = Project.generate!
                 parent_version_1 = Version.generate!(:project => project)
                 parent_version_2 = Version.generate!(:project => project)
                 assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions
               end
               test "#rolled_up_versions should include versions for a subproject" do
                 project = Project.generate!
                 parent_version_1 = Version.generate!(:project => project)
                 parent_version_2 = Version.generate!(:project => project)
                 subproject = Project.generate_with_parent!(project)
                 subproject_version = Version.generate!(:project => subproject)
                 assert_same_elements [
                                       parent_version_1,
                                       parent_version_2,
                                       subproject_version
                                      ], project.rolled_up_versions
               end
               test "#rolled_up_versions should include versions for a sub-subproject" do
                 project = Project.generate!
                 parent_version_1 = Version.generate!(:project => project)
                 parent_version_2 = Version.generate!(:project => project)
                 subproject = Project.generate_with_parent!(project)
                 sub_subproject = Project.generate_with_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
               test "#rolled_up_versions should only check active projects" do
                 project = Project.generate!
                 parent_version_1 = Version.generate!(:project => project)
                 parent_version_2 = Version.generate!(:project => project)
                 subproject = Project.generate_with_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
               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 [7], Version.where(:sharing => 'system').all.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_shared_versions_for_new_project_should_include_system_shared_versions
                 p = Project.find(5)
                 v = Version.create!(:name => 'system_sharing', :project => p, :sharing => 'system')
                 assert_include v, Project.new.shared_versions
               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
               test "enabled_modules should define module by names and preserve ids" do
                 @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
               test "enabled_modules should enable a module" do
                 @project = Project.find(1)
                 @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
               test "enabled_modules should disable a module" do
                 @project = Project.find(1)
                 #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
               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.where(:active => true).all
               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.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.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.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.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.create!(:name => "Project", :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
               test "#start_date should be nil if there are no issues on the project" do
                 project = Project.generate!
                 assert_nil project.start_date
               end
               test "#start_date should be nil when issues have no start date" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 early = 7.days.ago.to_date
                 Issue.generate!(:project => project, :start_date => nil)
                 assert_nil project.start_date
               end
               test "#start_date should be the earliest start date of it's issues" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 early = 7.days.ago.to_date
                 Issue.generate!(:project => project, :start_date => Date.today)
                 Issue.generate!(:project => project, :start_date => early)
                 assert_equal early, project.start_date
               end
               test "#due_date should be nil if there are no issues on the project" do
                 project = Project.generate!
                 assert_nil project.due_date
               end
               test "#due_date should be nil if there are no issues with due dates" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 Issue.generate!(:project => project, :due_date => nil)
                 assert_nil project.due_date
               end
               test "#due_date should be the latest due date of it's issues" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 future = 7.days.from_now.to_date
                 Issue.generate!(:project => project, :due_date => future)
                 Issue.generate!(:project => project, :due_date => Date.today)
                 assert_equal future, project.due_date
               end
               test "#due_date should be the latest due date of it's versions" do
                 project = Project.generate!
                 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
               test "#due_date should pick the latest date from it's issues and versions" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 future = 7.days.from_now.to_date
                 far_future = 14.days.from_now.to_date
                 Issue.generate!(:project => project, :due_date => far_future)
                 project.versions << Version.generate!(:effective_date => future)
                 assert_equal far_future, project.due_date
               end
               test "#completed_percent with no versions should be 100" do
                 project = Project.generate!
                 assert_equal 100, project.completed_percent
               end
               test "#completed_percent with versions should return 0 if the versions have no issues" do
                 project = Project.generate!
                 Version.generate!(:project => project)
                 Version.generate!(:project => project)
                 assert_equal 0, project.completed_percent
               end
               test "#completed_percent with versions should return 100 if the version has only closed issues" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 v1 = Version.generate!(:project => project)
                 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v1)
                 v2 = Version.generate!(:project => project)
                 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('Closed'), :fixed_version => v2)
                 assert_equal 100, project.completed_percent
               end
               test "#completed_percent with versions should return the averaged completed percent of the versions (not weighted)" do
                 project = Project.generate!
                 project.trackers << Tracker.generate!
                 v1 = Version.generate!(:project => project)
                 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v1)
                 v2 = Version.generate!(:project => project)
                 Issue.generate!(:project => project, :status => IssueStatus.find_by_name('New'), :estimated_hours => 10, :done_ratio => 50, :fixed_version => v2)
                 assert_equal 50, project.completed_percent
               end
               test "#notified_users" do
                 project = Project.generate!
                 role = Role.generate!
                 user_with_membership_notification = User.generate!(:mail_notification => 'selected')
                 Member.create!(:project => project, :roles => [role], :principal => user_with_membership_notification, :mail_notification => true)
                 all_events_user = User.generate!(:mail_notification => 'all')
                 Member.create!(:project => project, :roles => [role], :principal => all_events_user)
                 no_events_user = User.generate!(:mail_notification => 'none')
                 Member.create!(:project => project, :roles => [role], :principal => no_events_user)
                 only_my_events_user = User.generate!(:mail_notification => 'only_my_events')
                 Member.create!(:project => project, :roles => [role], :principal => only_my_events_user)
                 only_assigned_user = User.generate!(:mail_notification => 'only_assigned')
                 Member.create!(:project => project, :roles => [role], :principal => only_assigned_user)
                 only_owned_user = User.generate!(:mail_notification => 'only_owner')
                 Member.create!(:project => project, :roles => [role], :principal => only_owned_user)
                 assert project.notified_users.include?(user_with_membership_notification), "should include members with a mail notification"
                 assert project.notified_users.include?(all_events_user), "should include users with the 'all' notification option"
                 assert !project.notified_users.include?(no_events_user), "should not include users with the 'none' notification option"
                 assert !project.notified_users.include?(only_my_events_user), "should not include users with the 'only_my_events' notification option"
                 assert !project.notified_users.include?(only_assigned_user), "should not include users with the 'only_assigned' notification option"
                 assert !project.notified_users.include?(only_owned_user), "should not include users with the 'only_owner' notification option"
               end
             end