jro_apps/redmine Commit - r12281:7960f543a401

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.where(:id => 1).update_all(["identifier = ''"])

136

Project.where(:id => 1).update_all(["identifier = ''"])

137

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

137

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

138

end

138

end

139

140

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

140

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

141

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

141

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

142

end

142

end

143

144

def test_members_should_be_active_users

144

def test_members_should_be_active_users

145

Project.all.each do |project|

145

Project.all.each do |project|

146

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

146

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

147

end

147

end

148

end

148

end

149

150

def test_users_should_be_active_users

150

def test_users_should_be_active_users

151

Project.all.each do |project|

151

Project.all.each do |project|

152

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

152

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

153

end

153

end

154

end

154

end

155

156

def test_open_scope_on_issues_association

156

def test_open_scope_on_issues_association

157

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

157

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

158

end

158

end

159

160

def test_archive

160

def test_archive

161

user = @ecookbook.members.first.user

161

user = @ecookbook.members.first.user

162

@ecookbook.archive

162

@ecookbook.archive

163

@ecookbook.reload

163

@ecookbook.reload

164

165

assert !@ecookbook.active?

165

assert !@ecookbook.active?

166

assert @ecookbook.archived?

166

assert @ecookbook.archived?

167

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

167

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

168

# Subproject are also archived

168

# Subproject are also archived

169

assert !@ecookbook.children.empty?

169

assert !@ecookbook.children.empty?

170

assert @ecookbook.descendants.active.empty?

170

assert @ecookbook.descendants.active.empty?

171

end

171

end

172

173

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

173

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

174

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

174

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

175

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

175

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

176

177

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

177

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

178

assert_equal false, @ecookbook.archive

178

assert_equal false, @ecookbook.archive

179

end

179

end

180

@ecookbook.reload

180

@ecookbook.reload

181

assert @ecookbook.active?

181

assert @ecookbook.active?

182

end

182

end

183

184

def test_unarchive

184

def test_unarchive

185

user = @ecookbook.members.first.user

185

user = @ecookbook.members.first.user

186

@ecookbook.archive

186

@ecookbook.archive

187

# A subproject of an archived project can not be unarchived

187

# A subproject of an archived project can not be unarchived

188

assert !@ecookbook_sub1.unarchive

188

assert !@ecookbook_sub1.unarchive

189

190

# Unarchive project

190

# Unarchive project

191

assert @ecookbook.unarchive

191

assert @ecookbook.unarchive

192

@ecookbook.reload

192

@ecookbook.reload

193

assert @ecookbook.active?

193

assert @ecookbook.active?

194

assert !@ecookbook.archived?

194

assert !@ecookbook.archived?

195

assert user.projects.include?(@ecookbook)

195

assert user.projects.include?(@ecookbook)

196

# Subproject can now be unarchived

196

# Subproject can now be unarchived

197

@ecookbook_sub1.reload

197

@ecookbook_sub1.reload

198

assert @ecookbook_sub1.unarchive

198

assert @ecookbook_sub1.unarchive

199

end

199

end

200

201

def test_destroy

201

def test_destroy

202

# 2 active members

202

# 2 active members

203

assert_equal 2, @ecookbook.members.size

203

assert_equal 2, @ecookbook.members.size

204

# and 1 is locked

204

# and 1 is locked

205

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

205

assert_equal 3, Member.where(:project_id => @ecookbook.id).count

206

# some boards

206

# some boards

207

assert @ecookbook.boards.any?

207

assert @ecookbook.boards.any?

208

209

@ecookbook.destroy

209

@ecookbook.destroy

210

# make sure that the project non longer exists

210

# make sure that the project non longer exists

211

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

211

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

212

# make sure related data was removed

212

# make sure related data was removed

213

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

213

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

214

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

214

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

215

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

215

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

216

end

216

end

217

218

def test_destroy_should_destroy_subtasks

218

def test_destroy_should_destroy_subtasks

219

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

219

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

220

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

220

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

221

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

221

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

222

assert_equal 2, issues[1].children.count

222

assert_equal 2, issues[1].children.count

223

224

assert_nothing_raised do

224

assert_nothing_raised do

225

Project.find(1).destroy

225

Project.find(1).destroy

226

end

226

end

227

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

227

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

228

end

228

end

229

230

def test_destroying_root_projects_should_clear_data

230

def test_destroying_root_projects_should_clear_data

231

Project.roots.each do |root|

231

Project.roots.each do |root|

232

root.destroy

232

root.destroy

233

end

233

end

234

235

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

235

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

236

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

236

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

237

assert_equal 0, MemberRole.count

237

assert_equal 0, MemberRole.count

238

assert_equal 0, Issue.count

238

assert_equal 0, Issue.count

239

assert_equal 0, Journal.count

239

assert_equal 0, Journal.count

240

assert_equal 0, JournalDetail.count

240

assert_equal 0, JournalDetail.count

241

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

241

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

242

assert_equal 0, EnabledModule.count

242

assert_equal 0, EnabledModule.count

243

assert_equal 0, IssueCategory.count

243

assert_equal 0, IssueCategory.count

244

assert_equal 0, IssueRelation.count

244

assert_equal 0, IssueRelation.count

245

assert_equal 0, Board.count

245

assert_equal 0, Board.count

246

assert_equal 0, Message.count

246

assert_equal 0, Message.count

247

assert_equal 0, News.count

247

assert_equal 0, News.count

248

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

248

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

249

assert_equal 0, Repository.count

249

assert_equal 0, Repository.count

250

assert_equal 0, Changeset.count

250

assert_equal 0, Changeset.count

251

assert_equal 0, Change.count

251

assert_equal 0, Change.count

252

assert_equal 0, Comment.count

252

assert_equal 0, Comment.count

253

assert_equal 0, TimeEntry.count

253

assert_equal 0, TimeEntry.count

254

assert_equal 0, Version.count

254

assert_equal 0, Version.count

255

assert_equal 0, Watcher.count

255

assert_equal 0, Watcher.count

256

assert_equal 0, Wiki.count

256

assert_equal 0, Wiki.count

257

assert_equal 0, WikiPage.count

257

assert_equal 0, WikiPage.count

258

assert_equal 0, WikiContent.count

258

assert_equal 0, WikiContent.count

259

assert_equal 0, WikiContent::Version.count

259

assert_equal 0, WikiContent::Version.count

260

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

260

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

261

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

261

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

262

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

262

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

263

end

263

end

264

265

def test_destroy_should_delete_time_entries_custom_values

265

def test_destroy_should_delete_time_entries_custom_values

266

project = Project.generate!

266

project = Project.generate!

267

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

267

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

268

269

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

269

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

270

assert project.destroy

270

assert project.destroy

271

end

271

end

272

end

272

end

273

274

def test_move_an_orphan_project_to_a_root_project

274

def test_move_an_orphan_project_to_a_root_project

275

sub = Project.find(2)

275

sub = Project.find(2)

276

sub.set_parent! @ecookbook

276

sub.set_parent! @ecookbook

277

assert_equal @ecookbook.id, sub.parent.id

277

assert_equal @ecookbook.id, sub.parent.id

278

@ecookbook.reload

278

@ecookbook.reload

279

assert_equal 4, @ecookbook.children.size

279

assert_equal 4, @ecookbook.children.size

280

end

280

end

281

282

def test_move_an_orphan_project_to_a_subproject

282

def test_move_an_orphan_project_to_a_subproject

283

sub = Project.find(2)

283

sub = Project.find(2)

284

assert sub.set_parent!(@ecookbook_sub1)

284

assert sub.set_parent!(@ecookbook_sub1)

285

end

285

end

286

287

def test_move_a_root_project_to_a_project

287

def test_move_a_root_project_to_a_project

288

sub = @ecookbook

288

sub = @ecookbook

289

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

289

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

290

end

290

end

291

292

def test_should_not_move_a_project_to_its_children

292

def test_should_not_move_a_project_to_its_children

293

sub = @ecookbook

293

sub = @ecookbook

294

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

294

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

295

end

295

end

296

297

def test_set_parent_should_add_roots_in_alphabetical_order

297

def test_set_parent_should_add_roots_in_alphabetical_order

298

ProjectCustomField.delete_all

298

ProjectCustomField.delete_all

299

Project.delete_all

299

Project.delete_all

300

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

300

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

301

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

301

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

302

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

302

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

303

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

303

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

304

305

assert_equal 4, Project.count

305

assert_equal 4, Project.count

306

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

306

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

307

end

307

end

308

309

def test_set_parent_should_add_children_in_alphabetical_order

309

def test_set_parent_should_add_children_in_alphabetical_order

310

ProjectCustomField.delete_all

310

ProjectCustomField.delete_all

311

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

311

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

312

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

312

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

313

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

313

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

314

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

314

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

315

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

315

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

316

317

parent.reload

317

parent.reload

318

assert_equal 4, parent.children.size

318

assert_equal 4, parent.children.size

319

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

319

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

320

end

320

end

321

322

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

322

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

323

# Parent issue with a hierarchy project's fixed version

323

# Parent issue with a hierarchy project's fixed version

324

parent_issue = Issue.find(1)

324

parent_issue = Issue.find(1)

325

parent_issue.update_attribute(:fixed_version_id, 4)

325

parent_issue.update_attribute(:fixed_version_id, 4)

326

parent_issue.reload

326

parent_issue.reload

327

assert_equal 4, parent_issue.fixed_version_id

327

assert_equal 4, parent_issue.fixed_version_id

328

329

# Should keep fixed versions for the issues

329

# Should keep fixed versions for the issues

330

issue_with_local_fixed_version = Issue.find(5)

330

issue_with_local_fixed_version = Issue.find(5)

331

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

331

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

332

issue_with_local_fixed_version.reload

332

issue_with_local_fixed_version.reload

333

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

333

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

334

335

# Local issue with hierarchy fixed_version

335

# Local issue with hierarchy fixed_version

336

issue_with_hierarchy_fixed_version = Issue.find(13)

336

issue_with_hierarchy_fixed_version = Issue.find(13)

337

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

337

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

338

issue_with_hierarchy_fixed_version.reload

338

issue_with_hierarchy_fixed_version.reload

339

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

339

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

340

341

# Move project out of the issue's hierarchy

341

# Move project out of the issue's hierarchy

342

moved_project = Project.find(3)

342

moved_project = Project.find(3)

343

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

343

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

344

parent_issue.reload

344

parent_issue.reload

345

issue_with_local_fixed_version.reload

345

issue_with_local_fixed_version.reload

346

issue_with_hierarchy_fixed_version.reload

346

issue_with_hierarchy_fixed_version.reload

347

348

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

348

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 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"

349

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, parent_issue.fixed_version_id, "Fixed version is still set after moving the Version out of the hierarchy for the issue."

350

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

end

351

end

352

353

def test_parent

353

def test_parent

354

p = Project.find(6).parent

354

p = Project.find(6).parent

355

assert p.is_a?(Project)

355

assert p.is_a?(Project)

356

assert_equal 5, p.id

356

assert_equal 5, p.id

357

end

357

end

358

359

def test_ancestors

359

def test_ancestors

360

a = Project.find(6).ancestors

360

a = Project.find(6).ancestors

361

assert a.first.is_a?(Project)

361

assert a.first.is_a?(Project)

362

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

362

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

363

end

363

end

364

365

def test_root

365

def test_root

366

r = Project.find(6).root

366

r = Project.find(6).root

367

assert r.is_a?(Project)

367

assert r.is_a?(Project)

368

assert_equal 1, r.id

368

assert_equal 1, r.id

369

end

369

end

370

371

def test_children

371

def test_children

372

c = Project.find(1).children

372

c = Project.find(1).children

373

assert c.first.is_a?(Project)

373

assert c.first.is_a?(Project)

374

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

374

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

375

end

375

end

376

377

def test_descendants

377

def test_descendants

378

d = Project.find(1).descendants

378

d = Project.find(1).descendants

379

assert d.first.is_a?(Project)

379

assert d.first.is_a?(Project)

380

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

380

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

381

end

381

end

382

383

def test_allowed_parents_should_be_empty_for_non_member_user

383

def test_allowed_parents_should_be_empty_for_non_member_user

384

Role.non_member.add_permission!(:add_project)

384

Role.non_member.add_permission!(:add_project)

385

user = User.find(9)

385

user = User.find(9)

386

assert user.memberships.empty?

386

assert user.memberships.empty?

387

User.current = user

387

User.current = user

388

assert Project.new.allowed_parents.compact.empty?

388

assert Project.new.allowed_parents.compact.empty?

389

end

389

end

390

391

def test_allowed_parents_with_add_subprojects_permission

391

def test_allowed_parents_with_add_subprojects_permission

392

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

392

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

393

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

393

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

394

User.current = User.find(2)

394

User.current = User.find(2)

395

# new project

395

# new project

396

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

396

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

397

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

397

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

398

# existing root project

398

# existing root project

399

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

399

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

400

# existing child

400

# existing child

401

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

401

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

402

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

402

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

403

end

403

end

404

405

def test_allowed_parents_with_add_project_permission

405

def test_allowed_parents_with_add_project_permission

406

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

406

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

407

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

407

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

408

User.current = User.find(2)

408

User.current = User.find(2)

409

# new project

409

# new project

410

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

410

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

411

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

411

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

412

# existing root project

412

# existing root project

413

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

413

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

414

# existing child

414

# existing child

415

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

415

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

416

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

416

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

417

end

417

end

418

419

def test_allowed_parents_with_add_project_and_subprojects_permission

419

def test_allowed_parents_with_add_project_and_subprojects_permission

420

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

420

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

421

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

421

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

422

User.current = User.find(2)

422

User.current = User.find(2)

423

# new project

423

# new project

424

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

424

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

425

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

425

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

426

# existing root project

426

# existing root project

427

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

427

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

428

# existing child

428

# existing child

429

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

429

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

430

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

430

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

431

end

431

end

432

433

def test_users_by_role

433

def test_users_by_role

434

users_by_role = Project.find(1).users_by_role

434

users_by_role = Project.find(1).users_by_role

435

assert_kind_of Hash, users_by_role

435

assert_kind_of Hash, users_by_role

436

role = Role.find(1)

436

role = Role.find(1)

437

assert_kind_of Array, users_by_role[role]

437

assert_kind_of Array, users_by_role[role]

438

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

438

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

439

end

439

end

440

441

def test_rolled_up_trackers

441

def test_rolled_up_trackers

442

parent = Project.find(1)

442

parent = Project.find(1)

443

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

443

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

444

child = parent.children.find(3)

444

child = parent.children.find(3)

445

446

assert_equal [1, 2], parent.tracker_ids

446

assert_equal [1, 2], parent.tracker_ids

447

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

447

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

448

449

assert_kind_of Tracker, parent.rolled_up_trackers.first

449

assert_kind_of Tracker, parent.rolled_up_trackers.first

450

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

450

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

451

452

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

452

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

453

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

453

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

454

end

454

end

455

456

def test_rolled_up_trackers_should_ignore_archived_subprojects

456

def test_rolled_up_trackers_should_ignore_archived_subprojects

457

parent = Project.find(1)

457

parent = Project.find(1)

458

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

458

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

459

child = parent.children.find(3)

459

child = parent.children.find(3)

460

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

460

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

461

parent.children.each(&:archive)

461

parent.children.each(&:archive)

462

463

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

463

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

464

end

464

end

465

466

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

466

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

467

parent = Project.generate!

467

parent = Project.generate!

468

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

468

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

469

child = Project.generate_with_parent!(parent)

469

child = Project.generate_with_parent!(parent)

470

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

470

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

471

472

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

472

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

473

474

assert child.disable_module!(:issue_tracking)

474

assert child.disable_module!(:issue_tracking)

475

parent.reload

475

parent.reload

476

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

476

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

477

end

477

end

478

479

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

479

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

480

project = Project.generate!

480

project = Project.generate!

481

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

481

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

482

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

482

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

483

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

483

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

484

end

484

end

485

486

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

486

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

487

project = Project.generate!

487

project = Project.generate!

488

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

488

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

489

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

489

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

490

subproject = Project.generate_with_parent!(project)

490

subproject = Project.generate_with_parent!(project)

491

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

491

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

492

493

assert_same_elements [

493

assert_same_elements [

494

parent_version_1,

494

parent_version_1,

495

parent_version_2,

495

parent_version_2,

496

subproject_version

496

subproject_version

497

], project.rolled_up_versions

497

], project.rolled_up_versions

498

end

498

end

499

500

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

500

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

501

project = Project.generate!

501

project = Project.generate!

502

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

502

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

503

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

503

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

504

subproject = Project.generate_with_parent!(project)

504

subproject = Project.generate_with_parent!(project)

505

sub_subproject = Project.generate_with_parent!(subproject)

505

sub_subproject = Project.generate_with_parent!(subproject)

506

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

506

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

507

project.reload

507

project.reload

508

509

assert_same_elements [

509

assert_same_elements [

510

parent_version_1,

510

parent_version_1,

511

parent_version_2,

511

parent_version_2,

512

sub_subproject_version

512

sub_subproject_version

513

], project.rolled_up_versions

513

], project.rolled_up_versions

514

end

514

end

515

516

test "#rolled_up_versions should only check active projects" do

516

test "#rolled_up_versions should only check active projects" do

517

project = Project.generate!

517

project = Project.generate!

518

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

518

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

519

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

519

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

520

subproject = Project.generate_with_parent!(project)

520

subproject = Project.generate_with_parent!(project)

521

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

521

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

522

assert subproject.archive

522

assert subproject.archive

523

project.reload

523

project.reload

524

525

assert !subproject.active?

525

assert !subproject.active?

526

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

526

assert_same_elements [parent_version_1, parent_version_2], project.rolled_up_versions

527

end

527

end

528

529

def test_shared_versions_none_sharing

529

def test_shared_versions_none_sharing

530

p = Project.find(5)

530

p = Project.find(5)

531

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

531

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

532

assert p.shared_versions.include?(v)

532

assert p.shared_versions.include?(v)

533

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

533

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

534

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

534

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

535

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

535

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

536

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

536

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

537

end

537

end

538

539

def test_shared_versions_descendants_sharing

539

def test_shared_versions_descendants_sharing

540

p = Project.find(5)

540

p = Project.find(5)

541

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

541

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

542

assert p.shared_versions.include?(v)

542

assert p.shared_versions.include?(v)

543

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

543

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

544

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

544

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

545

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

545

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

546

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

546

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

547

end

547

end

548

549

def test_shared_versions_hierarchy_sharing

549

def test_shared_versions_hierarchy_sharing

550

p = Project.find(5)

550

p = Project.find(5)

551

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

551

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

552

assert p.shared_versions.include?(v)

552

assert p.shared_versions.include?(v)

553

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

553

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

554

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

554

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

555

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

555

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

556

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

556

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

557

end

557

end

558

559

def test_shared_versions_tree_sharing

559

def test_shared_versions_tree_sharing

560

p = Project.find(5)

560

p = Project.find(5)

561

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

561

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

562

assert p.shared_versions.include?(v)

562

assert p.shared_versions.include?(v)

563

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

563

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

564

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

564

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

565

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

565

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

566

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

566

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

567

end

567

end

568

569

def test_shared_versions_system_sharing

569

def test_shared_versions_system_sharing

570

p = Project.find(5)

570

p = Project.find(5)

571

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

571

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

572

assert p.shared_versions.include?(v)

572

assert p.shared_versions.include?(v)

573

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

573

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

574

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

574

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

575

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

575

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

576

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

576

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

577

end

577

end

578

579

def test_shared_versions

579

def test_shared_versions

580

parent = Project.find(1)

580

parent = Project.find(1)

581

child = parent.children.find(3)

581

child = parent.children.find(3)

582

private_child = parent.children.find(5)

582

private_child = parent.children.find(5)

583

584

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

584

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

585

assert_equal [4], child.version_ids

585

assert_equal [4], child.version_ids

586

assert_equal [6], private_child.version_ids

586

assert_equal [6], private_child.version_ids

587

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

587

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

588

589

assert_equal 6, parent.shared_versions.size

589

assert_equal 6, parent.shared_versions.size

590

parent.shared_versions.each do |version|

590

parent.shared_versions.each do |version|

591

assert_kind_of Version, version

591

assert_kind_of Version, version

592

end

592

end

593

594

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

594

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

595

end

595

end

596

597

def test_shared_versions_should_ignore_archived_subprojects

597

def test_shared_versions_should_ignore_archived_subprojects

598

parent = Project.find(1)

598

parent = Project.find(1)

599

child = parent.children.find(3)

599

child = parent.children.find(3)

600

child.archive

600

child.archive

601

parent.reload

601

parent.reload

602

603

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

603

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

604

assert_equal [4], child.version_ids

604

assert_equal [4], child.version_ids

605

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

605

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

606

end

606

end

607

608

def test_shared_versions_visible_to_user

608

def test_shared_versions_visible_to_user

609

user = User.find(3)

609

user = User.find(3)

610

parent = Project.find(1)

610

parent = Project.find(1)

611

child = parent.children.find(5)

611

child = parent.children.find(5)

612

613

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

613

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

614

assert_equal [6], child.version_ids

614

assert_equal [6], child.version_ids

615

616

versions = parent.shared_versions.visible(user)

616

versions = parent.shared_versions.visible(user)

617

618

assert_equal 4, versions.size

618

assert_equal 4, versions.size

619

versions.each do |version|

619

versions.each do |version|

620

assert_kind_of Version, version

620

assert_kind_of Version, version

621

end

621

end

622

623

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

623

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

624

end

624

end

625

626

def test_shared_versions_for_new_project_should_include_system_shared_versions

626

def test_shared_versions_for_new_project_should_include_system_shared_versions

627

p = Project.find(5)

627

p = Project.find(5)

628

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

628

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

629

630

assert_include v, Project.new.shared_versions

630

assert_include v, Project.new.shared_versions

631

end

631

end

632

633

def test_next_identifier

633

def test_next_identifier

634

ProjectCustomField.delete_all

634

ProjectCustomField.delete_all

635

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

635

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

636

assert_equal 'p2008041', Project.next_identifier

636

assert_equal 'p2008041', Project.next_identifier

637

end

637

end

638

639

def test_next_identifier_first_project

639

def test_next_identifier_first_project

640

Project.delete_all

640

Project.delete_all

641

assert_nil Project.next_identifier

641

assert_nil Project.next_identifier

642

end

642

end

643

644

def test_enabled_module_names

644

def test_enabled_module_names

645

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

645

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

646

project = Project.new

646

project = Project.new

647

648

project.enabled_module_names = %w(issue_tracking news)

648

project.enabled_module_names = %w(issue_tracking news)

649

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

649

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

650

end

650

end

651

end

651

end

652

653

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

653

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

654

@project = Project.find(1)

654

@project = Project.find(1)

655

# Remove one module

655

# Remove one module

656

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

656

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

657

assert modules.any?

657

assert modules.any?

658

assert_difference 'EnabledModule.count', -1 do

658

assert_difference 'EnabledModule.count', -1 do

659

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

659

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

660

end

660

end

661

@project.reload

661

@project.reload

662

# Ids should be preserved

662

# Ids should be preserved

663

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

663

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

664

end

664

end

665

666

test "enabled_modules should enable a module" do

666

test "enabled_modules should enable a module" do

667

@project = Project.find(1)

667

@project = Project.find(1)

668

@project.enabled_module_names = []

668

@project.enabled_module_names = []

669

@project.reload

669

@project.reload

670

assert_equal [], @project.enabled_module_names

670

assert_equal [], @project.enabled_module_names

671

#with string

671

#with string

672

@project.enable_module!("issue_tracking")

672

@project.enable_module!("issue_tracking")

673

assert_equal ["issue_tracking"], @project.enabled_module_names

673

assert_equal ["issue_tracking"], @project.enabled_module_names

674

#with symbol

674

#with symbol

675

@project.enable_module!(:gantt)

675

@project.enable_module!(:gantt)

676

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

676

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

677

#don't add a module twice

677

#don't add a module twice

678

@project.enable_module!("issue_tracking")

678

@project.enable_module!("issue_tracking")

679

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

679

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

680

end

680

end

681

682

test "enabled_modules should disable a module" do

682

test "enabled_modules should disable a module" do

683

@project = Project.find(1)

683

@project = Project.find(1)

684

#with string

684

#with string

685

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

685

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

686

@project.disable_module!("issue_tracking")

686

@project.disable_module!("issue_tracking")

687

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

687

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

688

#with symbol

688

#with symbol

689

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

689

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

690

@project.disable_module!(:gantt)

690

@project.disable_module!(:gantt)

691

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

691

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

692

#with EnabledModule object

692

#with EnabledModule object

693

first_module = @project.enabled_modules.first

693

first_module = @project.enabled_modules.first

694

@project.disable_module!(first_module)

694

@project.disable_module!(first_module)

695

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

695

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

696

end

696

end

697

698

def test_enabled_module_names_should_not_recreate_enabled_modules

698

def test_enabled_module_names_should_not_recreate_enabled_modules

699

project = Project.find(1)

699

project = Project.find(1)

700

# Remove one module

700

# Remove one module

701

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

701

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

702

assert modules.any?

702

assert modules.any?

703

assert_difference 'EnabledModule.count', -1 do

703

assert_difference 'EnabledModule.count', -1 do

704

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

704

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

705

end

705

end

706

project.reload

706

project.reload

707

# Ids should be preserved

707

# Ids should be preserved

708

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

708

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

709

end

709

end

710

711

def test_copy_from_existing_project

711

def test_copy_from_existing_project

712

source_project = Project.find(1)

712

source_project = Project.find(1)

713

copied_project = Project.copy_from(1)

713

copied_project = Project.copy_from(1)

714

715

assert copied_project

715

assert copied_project

716

# Cleared attributes

716

# Cleared attributes

717

assert copied_project.id.blank?

717

assert copied_project.id.blank?

718

assert copied_project.name.blank?

718

assert copied_project.name.blank?

719

assert copied_project.identifier.blank?

719

assert copied_project.identifier.blank?

720

721

# Duplicated attributes

721

# Duplicated attributes

722

assert_equal source_project.description, copied_project.description

722

assert_equal source_project.description, copied_project.description

723

assert_equal source_project.enabled_modules, copied_project.enabled_modules

723

assert_equal source_project.enabled_modules, copied_project.enabled_modules

724

assert_equal source_project.trackers, copied_project.trackers

724

assert_equal source_project.trackers, copied_project.trackers

725

726

# Default attributes

726

# Default attributes

727

assert_equal 1, copied_project.status

727

assert_equal 1, copied_project.status

728

end

728

end

729

730

def test_activities_should_use_the_system_activities

730

def test_activities_should_use_the_system_activities

731

project = Project.find(1)

731

project = Project.find(1)

732

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

732

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

733

end

733

end

734

735

736

def test_activities_should_use_the_project_specific_activities

736

def test_activities_should_use_the_project_specific_activities

737

project = Project.find(1)

737

project = Project.find(1)

738

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

738

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

739

assert overridden_activity.save!

739

assert overridden_activity.save!

740

741

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

741

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

742

end

742

end

743

744

def test_activities_should_not_include_the_inactive_project_specific_activities

744

def test_activities_should_not_include_the_inactive_project_specific_activities

745

project = Project.find(1)

745

project = Project.find(1)

746

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

746

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

747

assert overridden_activity.save!

747

assert overridden_activity.save!

748

749

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

749

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

750

end

750

end

751

752

def test_activities_should_not_include_project_specific_activities_from_other_projects

752

def test_activities_should_not_include_project_specific_activities_from_other_projects

753

project = Project.find(1)

753

project = Project.find(1)

754

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

754

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

755

assert overridden_activity.save!

755

assert overridden_activity.save!

756

757

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

757

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

758

end

758

end

759

760

def test_activities_should_handle_nils

760

def test_activities_should_handle_nils

761

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

761

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

762

TimeEntryActivity.delete_all

762

TimeEntryActivity.delete_all

763

764

# No activities

764

# No activities

765

project = Project.find(1)

765

project = Project.find(1)

766

assert project.activities.empty?

766

assert project.activities.empty?

767

768

# No system, one overridden

768

# No system, one overridden

769

assert overridden_activity.save!

769

assert overridden_activity.save!

770

project.reload

770

project.reload

771

assert_equal [overridden_activity], project.activities

771

assert_equal [overridden_activity], project.activities

772

end

772

end

773

774

def test_activities_should_override_system_activities_with_project_activities

774

def test_activities_should_override_system_activities_with_project_activities

775

project = Project.find(1)

775

project = Project.find(1)

776

parent_activity = TimeEntryActivity.first

776

parent_activity = TimeEntryActivity.first

777

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

777

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

778

assert overridden_activity.save!

778

assert overridden_activity.save!

779

780

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

780

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

781

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

781

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

782

end

782

end

783

784

def test_activities_should_include_inactive_activities_if_specified

784

def test_activities_should_include_inactive_activities_if_specified

785

project = Project.find(1)

785

project = Project.find(1)

786

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

786

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

787

assert overridden_activity.save!

787

assert overridden_activity.save!

788

789

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

789

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

790

end

790

end

791

792

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

792

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

793

project = Project.find(1)

793

project = Project.find(1)

794

system_activity = TimeEntryActivity.find_by_name('Design')

794

system_activity = TimeEntryActivity.find_by_name('Design')

795

assert system_activity.active?

795

assert system_activity.active?

796

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

796

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

797

assert overridden_activity.save!

797

assert overridden_activity.save!

798

799

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

799

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

800

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

800

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

801

end

801

end

802

803

def test_close_completed_versions

803

def test_close_completed_versions

804

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

804

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

805

project = Project.find(1)

805

project = Project.find(1)

806

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

806

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

807

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

808

project.close_completed_versions

808

project.close_completed_versions

809

project.reload

809

project.reload

810

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

810

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

811

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

811

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

812

end

812

end

813

814

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

814

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

815

project = Project.generate!

815

project = Project.generate!

816

assert_nil project.start_date

816

assert_nil project.start_date

817

end

817

end

818

819

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

819

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

820

project = Project.generate!

820

project = Project.generate!

821

project.trackers << Tracker.generate!

821

project.trackers << Tracker.generate!

822

early = 7.days.ago.to_date

822

early = 7.days.ago.to_date

823

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

823

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

824

825

assert_nil project.start_date

825

assert_nil project.start_date

826

end

826

end

827

828

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

828

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

829

project = Project.generate!

829

project = Project.generate!

830

project.trackers << Tracker.generate!

830

project.trackers << Tracker.generate!

831

early = 7.days.ago.to_date

831

early = 7.days.ago.to_date

832

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

832

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

833

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

833

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

834

835

assert_equal early, project.start_date

835

assert_equal early, project.start_date

836

end

836

end

837

838

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

838

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

839

project = Project.generate!

839

project = Project.generate!

840

assert_nil project.due_date

840

assert_nil project.due_date

841

end

841

end

842

843

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

843

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

844

project = Project.generate!

844

project = Project.generate!

845

project.trackers << Tracker.generate!

845

project.trackers << Tracker.generate!

846

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

846

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

847

848

assert_nil project.due_date

848

assert_nil project.due_date

849

end

849

end

850

851

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

851

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

852

project = Project.generate!

852

project = Project.generate!

853

project.trackers << Tracker.generate!

853

project.trackers << Tracker.generate!

854

future = 7.days.from_now.to_date

854

future = 7.days.from_now.to_date

855

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

855

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

856

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

856

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

857

858

assert_equal future, project.due_date

858

assert_equal future, project.due_date

859

end

859

end

860

861

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

861

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

862

project = Project.generate!

862

project = Project.generate!

863

future = 7.days.from_now.to_date

863

future = 7.days.from_now.to_date

864

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

864

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

865

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

865

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

866

867

assert_equal future, project.due_date

867

assert_equal future, project.due_date

868

end

868

end

869

870

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

870

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

871

project = Project.generate!

871

project = Project.generate!

872

project.trackers << Tracker.generate!

872

project.trackers << Tracker.generate!

873

future = 7.days.from_now.to_date

873

future = 7.days.from_now.to_date

874

far_future = 14.days.from_now.to_date

874

far_future = 14.days.from_now.to_date

875

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

875

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

876

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

876

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

877

878

assert_equal far_future, project.due_date

878

assert_equal far_future, project.due_date

879

end

879

end

880

881

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

881

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

882

project = Project.generate!

882

project = Project.generate!

883

assert_equal 100, project.completed_percent

883

assert_equal 100, project.completed_percent

884

end

884

end

885

886

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

886

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

887

project = Project.generate!

887

project = Project.generate!

888

Version.generate!(:project => project)

888

Version.generate!(:project => project)

889

Version.generate!(:project => project)

889

Version.generate!(:project => project)

890

891

assert_equal 0, project.completed_percent

891

assert_equal 0, project.completed_percent

892

end

892

end

893

894

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

894

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

895

project = Project.generate!

895

project = Project.generate!

896

project.trackers << Tracker.generate!

896

project.trackers << Tracker.generate!

897

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

897

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

898

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

898

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

899

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

899

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

900

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

900

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

901

902

assert_equal 100, project.completed_percent

902

assert_equal 100, project.completed_percent

903

end

903

end

904

905

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

905

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

906

project = Project.generate!

906

project = Project.generate!

907

project.trackers << Tracker.generate!

907

project.trackers << Tracker.generate!

908

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

908

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

909

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

909

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

910

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

910

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

911

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

911

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

912

913

assert_equal 50, project.completed_percent

913

assert_equal 50, project.completed_percent

914

end

914

end

915

916

test "#notified_users" do

916

test "#notified_users" do

917

project = Project.generate!

917

project = Project.generate!

918

role = Role.generate!

918

role = Role.generate!

919

920

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

920

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

921

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

921

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

922

923

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

923

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

924

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

924

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

925

926

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

926

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

927

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

927

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

928

929

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

929

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

930

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

930

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

931

932

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

932

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

933

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

933

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

934

935

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

935

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

936

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

936

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

937

938

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

938

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

939

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

939

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

940

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

940

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

941

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

941

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_assigned_user), "should not include users with the 'only_assigned' notification option"

942

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_owned_user), "should not include users with the 'only_owner' notification option"

943

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

944

end

944

end

945

end

945

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.where(:id => 1).update_all(["identifier = ''"])
                 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
+                assert_equal 3, Member.where(:project_id => @ecookbook.id).count
                 # 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.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