jro_apps/redmine Commit - r14475:151892c3131a

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

:workflows

40

:workflows

41

42

def setup

42

def setup

43

@ecookbook = Project.find(1)

43

@ecookbook = Project.find(1)

44

@ecookbook_sub1 = Project.find(3)

44

@ecookbook_sub1 = Project.find(3)

45

set_tmp_attachments_directory

45

set_tmp_attachments_directory

46

User.current = nil

46

User.current = nil

47

end

47

end

48

49

def test_truth

49

def test_truth

50

assert_kind_of Project, @ecookbook

50

assert_kind_of Project, @ecookbook

51

assert_equal "eCookbook", @ecookbook.name

51

assert_equal "eCookbook", @ecookbook.name

52

end

52

end

53

54

def test_default_attributes

54

def test_default_attributes

55

with_settings :default_projects_public => '1' do

55

with_settings :default_projects_public => '1' do

56

assert_equal true, Project.new.is_public

56

assert_equal true, Project.new.is_public

57

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

57

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

58

end

58

end

59

60

with_settings :default_projects_public => '0' do

60

with_settings :default_projects_public => '0' do

61

assert_equal false, Project.new.is_public

61

assert_equal false, Project.new.is_public

62

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

62

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

63

end

63

end

64

65

with_settings :sequential_project_identifiers => '1' do

65

with_settings :sequential_project_identifiers => '1' do

66

assert !Project.new.identifier.blank?

66

assert !Project.new.identifier.blank?

67

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

67

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

68

end

68

end

69

70

with_settings :sequential_project_identifiers => '0' do

70

with_settings :sequential_project_identifiers => '0' do

71

assert Project.new.identifier.blank?

71

assert Project.new.identifier.blank?

72

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

72

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

73

end

73

end

74

75

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

75

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

76

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

76

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

77

end

77

end

78

end

78

end

79

80

def test_default_trackers_should_match_default_tracker_ids_setting

80

def test_default_trackers_should_match_default_tracker_ids_setting

81

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

81

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

82

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

82

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

83

end

83

end

84

end

84

end

85

86

def test_default_trackers_should_be_all_trackers_with_blank_setting

86

def test_default_trackers_should_be_all_trackers_with_blank_setting

87

with_settings :default_projects_tracker_ids => nil do

87

with_settings :default_projects_tracker_ids => nil do

88

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

88

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

89

end

89

end

90

end

90

end

91

92

def test_default_trackers_should_be_empty_with_empty_setting

92

def test_default_trackers_should_be_empty_with_empty_setting

93

with_settings :default_projects_tracker_ids => [] do

93

with_settings :default_projects_tracker_ids => [] do

94

assert_equal [], Project.new.trackers

94

assert_equal [], Project.new.trackers

95

end

95

end

96

end

96

end

97

98

def test_default_trackers_should_not_replace_initialized_trackers

98

def test_default_trackers_should_not_replace_initialized_trackers

99

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

99

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

100

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

100

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

101

end

101

end

102

end

102

end

103

104

def test_update

104

def test_update

105

assert_equal "eCookbook", @ecookbook.name

105

assert_equal "eCookbook", @ecookbook.name

106

@ecookbook.name = "eCook"

106

@ecookbook.name = "eCook"

107

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

107

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

108

@ecookbook.reload

108

@ecookbook.reload

109

assert_equal "eCook", @ecookbook.name

109

assert_equal "eCook", @ecookbook.name

110

end

110

end

111

112

def test_validate_identifier

112

def test_validate_identifier

113

to_test = {"abc" => true,

113

to_test = {"abc" => true,

114

"ab12" => true,

114

"ab12" => true,

115

"ab-12" => true,

115

"ab-12" => true,

116

"ab_12" => true,

116

"ab_12" => true,

117

"12" => false,

117

"12" => false,

118

"new" => false}

118

"new" => false}

119

120

to_test.each do |identifier, valid|

120

to_test.each do |identifier, valid|

121

p = Project.new

121

p = Project.new

122

p.identifier = identifier

122

p.identifier = identifier

123

p.valid?

123

p.valid?

124

if valid

124

if valid

125

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

125

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

126

else

126

else

127

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

127

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

128

end

128

end

129

end

129

end

130

end

130

end

131

132

def test_identifier_should_not_be_frozen_for_a_new_project

132

def test_identifier_should_not_be_frozen_for_a_new_project

133

assert_equal false, Project.new.identifier_frozen?

133

assert_equal false, Project.new.identifier_frozen?

134

end

134

end

135

136

def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier

136

def test_identifier_should_not_be_frozen_for_a_saved_project_with_blank_identifier

137

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

137

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

138

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

138

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

139

end

139

end

140

141

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

141

def test_identifier_should_be_frozen_for_a_saved_project_with_valid_identifier

142

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

142

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

143

end

143

end

144

145

def test_to_param_should_be_nil_for_new_records

145

def test_to_param_should_be_nil_for_new_records

146

project = Project.new

146

project = Project.new

147

project.identifier = "foo"

147

project.identifier = "foo"

148

assert_nil project.to_param

148

assert_nil project.to_param

149

end

149

end

150

151

def test_members_should_be_active_users

151

def test_members_should_be_active_users

152

Project.all.each do |project|

152

Project.all.each do |project|

153

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

153

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

154

end

154

end

155

end

155

end

156

157

def test_users_should_be_active_users

157

def test_users_should_be_active_users

158

Project.all.each do |project|

158

Project.all.each do |project|

159

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

159

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

160

end

160

end

161

end

161

end

162

163

def test_open_scope_on_issues_association

163

def test_open_scope_on_issues_association

164

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

164

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

165

end

165

end

166

167

def test_archive

167

def test_archive

168

user = @ecookbook.members.first.user

168

user = @ecookbook.members.first.user

169

@ecookbook.archive

169

@ecookbook.archive

170

@ecookbook.reload

170

@ecookbook.reload

171

172

assert !@ecookbook.active?

172

assert !@ecookbook.active?

173

assert @ecookbook.archived?

173

assert @ecookbook.archived?

174

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

174

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

175

# Subproject are also archived

175

# Subproject are also archived

176

assert !@ecookbook.children.empty?

176

assert !@ecookbook.children.empty?

177

assert @ecookbook.descendants.active.empty?

177

assert @ecookbook.descendants.active.empty?

178

end

178

end

179

180

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

180

def test_archive_should_fail_if_versions_are_used_by_non_descendant_projects

181

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

181

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

182

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

182

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

183

184

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

184

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

185

assert_equal false, @ecookbook.archive

185

assert_equal false, @ecookbook.archive

186

end

186

end

187

@ecookbook.reload

187

@ecookbook.reload

188

assert @ecookbook.active?

188

assert @ecookbook.active?

189

end

189

end

190

191

def test_unarchive

191

def test_unarchive

192

user = @ecookbook.members.first.user

192

user = @ecookbook.members.first.user

193

@ecookbook.archive

193

@ecookbook.archive

194

# A subproject of an archived project can not be unarchived

194

# A subproject of an archived project can not be unarchived

195

assert !@ecookbook_sub1.unarchive

195

assert !@ecookbook_sub1.unarchive

196

197

# Unarchive project

197

# Unarchive project

198

assert @ecookbook.unarchive

198

assert @ecookbook.unarchive

199

@ecookbook.reload

199

@ecookbook.reload

200

assert @ecookbook.active?

200

assert @ecookbook.active?

201

assert !@ecookbook.archived?

201

assert !@ecookbook.archived?

202

assert user.projects.include?(@ecookbook)

202

assert user.projects.include?(@ecookbook)

203

# Subproject can now be unarchived

203

# Subproject can now be unarchived

204

@ecookbook_sub1.reload

204

@ecookbook_sub1.reload

205

assert @ecookbook_sub1.unarchive

205

assert @ecookbook_sub1.unarchive

206

end

206

end

207

208

def test_destroy

208

def test_destroy

209

# 2 active members

209

# 2 active members

210

assert_equal 2, @ecookbook.members.size

210

assert_equal 2, @ecookbook.members.size

211

# and 1 is locked

211

# and 1 is locked

212

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

212

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

213

# some boards

213

# some boards

214

assert @ecookbook.boards.any?

214

assert @ecookbook.boards.any?

215

216

@ecookbook.destroy

216

@ecookbook.destroy

217

# make sure that the project non longer exists

217

# make sure that the project non longer exists

218

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

218

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

219

# make sure related data was removed

219

# make sure related data was removed

220

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

220

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

221

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

221

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

222

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

222

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

223

end

223

end

224

225

def test_destroy_should_destroy_subtasks

225

def test_destroy_should_destroy_subtasks

226

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

226

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

227

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

227

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

228

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

228

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

229

assert_equal 2, issues[1].children.count

229

assert_equal 2, issues[1].children.count

230

231

assert_nothing_raised do

231

assert_nothing_raised do

232

Project.find(1).destroy

232

Project.find(1).destroy

233

end

233

end

234

assert_equal 0, Issue.where(:id => issues.map(&:id)).count

234

assert_equal 0, Issue.where(:id => issues.map(&:id)).count

235

end

235

end

236

237

def test_destroying_root_projects_should_clear_data

237

def test_destroying_root_projects_should_clear_data

238

Project.roots.each do |root|

238

Project.roots.each do |root|

239

root.destroy

239

root.destroy

240

end

240

end

241

242

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

242

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

243

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

243

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

244

assert_equal 0, MemberRole.count

244

assert_equal 0, MemberRole.count

245

assert_equal 0, Issue.count

245

assert_equal 0, Issue.count

246

assert_equal 0, Journal.count

246

assert_equal 0, Journal.count

247

assert_equal 0, JournalDetail.count

247

assert_equal 0, JournalDetail.count

248

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

248

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

249

assert_equal 0, EnabledModule.count

249

assert_equal 0, EnabledModule.count

250

assert_equal 0, IssueCategory.count

250

assert_equal 0, IssueCategory.count

251

assert_equal 0, IssueRelation.count

251

assert_equal 0, IssueRelation.count

252

assert_equal 0, Board.count

252

assert_equal 0, Board.count

253

assert_equal 0, Message.count

253

assert_equal 0, Message.count

254

assert_equal 0, News.count

254

assert_equal 0, News.count

255

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

255

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

256

assert_equal 0, Repository.count

256

assert_equal 0, Repository.count

257

assert_equal 0, Changeset.count

257

assert_equal 0, Changeset.count

258

assert_equal 0, Change.count

258

assert_equal 0, Change.count

259

assert_equal 0, Comment.count

259

assert_equal 0, Comment.count

260

assert_equal 0, TimeEntry.count

260

assert_equal 0, TimeEntry.count

261

assert_equal 0, Version.count

261

assert_equal 0, Version.count

262

assert_equal 0, Watcher.count

262

assert_equal 0, Watcher.count

263

assert_equal 0, Wiki.count

263

assert_equal 0, Wiki.count

264

assert_equal 0, WikiPage.count

264

assert_equal 0, WikiPage.count

265

assert_equal 0, WikiContent.count

265

assert_equal 0, WikiContent.count

266

assert_equal 0, WikiContent::Version.count

266

assert_equal 0, WikiContent::Version.count

267

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

267

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

268

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

268

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

269

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

269

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

270

end

270

end

271

272

def test_destroy_should_delete_time_entries_custom_values

272

def test_destroy_should_delete_time_entries_custom_values

273

project = Project.generate!

273

project = Project.generate!

274

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

274

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

275

276

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

276

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

277

assert project.destroy

277

assert project.destroy

278

end

278

end

279

end

279

end

280

281

def test_move_an_orphan_project_to_a_root_project

281

def test_move_an_orphan_project_to_a_root_project

282

sub = Project.find(2)

282

sub = Project.find(2)

283

sub.set_parent! @ecookbook

283

sub.set_parent! @ecookbook

284

assert_equal @ecookbook.id, sub.parent.id

284

assert_equal @ecookbook.id, sub.parent.id

285

@ecookbook.reload

285

@ecookbook.reload

286

assert_equal 4, @ecookbook.children.size

286

assert_equal 4, @ecookbook.children.size

287

end

287

end

288

289

def test_move_an_orphan_project_to_a_subproject

289

def test_move_an_orphan_project_to_a_subproject

290

sub = Project.find(2)

290

sub = Project.find(2)

291

assert sub.set_parent!(@ecookbook_sub1)

291

assert sub.set_parent!(@ecookbook_sub1)

292

end

292

end

293

294

def test_move_a_root_project_to_a_project

294

def test_move_a_root_project_to_a_project

295

sub = @ecookbook

295

sub = @ecookbook

296

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

296

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

297

end

297

end

298

299

def test_should_not_move_a_project_to_its_children

299

def test_should_not_move_a_project_to_its_children

300

sub = @ecookbook

300

sub = @ecookbook

301

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

301

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

302

end

302

end

303

304

def test_set_parent_should_add_roots_in_alphabetical_order

304

def test_set_parent_should_add_roots_in_alphabetical_order

305

ProjectCustomField.delete_all

305

ProjectCustomField.delete_all

306

Project.delete_all

306

Project.delete_all

307

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

307

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

308

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

308

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

309

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

309

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

310

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

310

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

311

312

assert_equal 4, Project.count

312

assert_equal 4, Project.count

313

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

313

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

314

end

314

end

315

316

def test_set_parent_should_add_children_in_alphabetical_order

316

def test_set_parent_should_add_children_in_alphabetical_order

317

ProjectCustomField.delete_all

317

ProjectCustomField.delete_all

318

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

318

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

319

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

319

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

320

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

320

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

321

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

321

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

322

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

322

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

323

324

parent.reload

324

parent.reload

325

assert_equal 4, parent.children.size

325

assert_equal 4, parent.children.size

326

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

326

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

327

end

327

end

328

329

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

329

def test_set_parent_should_update_issue_fixed_version_associations_when_a_fixed_version_is_moved_out_of_the_hierarchy

330

# Parent issue with a hierarchy project's fixed version

330

# Parent issue with a hierarchy project's fixed version

331

parent_issue = Issue.find(1)

331

parent_issue = Issue.find(1)

332

parent_issue.update_attribute(:fixed_version_id, 4)

332

parent_issue.update_attribute(:fixed_version_id, 4)

333

parent_issue.reload

333

parent_issue.reload

334

assert_equal 4, parent_issue.fixed_version_id

334

assert_equal 4, parent_issue.fixed_version_id

335

336

# Should keep fixed versions for the issues

336

# Should keep fixed versions for the issues

337

issue_with_local_fixed_version = Issue.find(5)

337

issue_with_local_fixed_version = Issue.find(5)

338

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

338

issue_with_local_fixed_version.update_attribute(:fixed_version_id, 4)

339

issue_with_local_fixed_version.reload

339

issue_with_local_fixed_version.reload

340

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

340

assert_equal 4, issue_with_local_fixed_version.fixed_version_id

341

342

# Local issue with hierarchy fixed_version

342

# Local issue with hierarchy fixed_version

343

issue_with_hierarchy_fixed_version = Issue.find(13)

343

issue_with_hierarchy_fixed_version = Issue.find(13)

344

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

344

issue_with_hierarchy_fixed_version.update_attribute(:fixed_version_id, 6)

345

issue_with_hierarchy_fixed_version.reload

345

issue_with_hierarchy_fixed_version.reload

346

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

346

assert_equal 6, issue_with_hierarchy_fixed_version.fixed_version_id

347

348

# Move project out of the issue's hierarchy

348

# Move project out of the issue's hierarchy

349

moved_project = Project.find(3)

349

moved_project = Project.find(3)

350

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

350

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

351

parent_issue.reload

351

parent_issue.reload

352

issue_with_local_fixed_version.reload

352

issue_with_local_fixed_version.reload

353

issue_with_hierarchy_fixed_version.reload

353

issue_with_hierarchy_fixed_version.reload

354

355

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

355

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

356

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"

356

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"

357

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

357

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

358

end

358

end

359

360

def test_parent

360

def test_parent

361

p = Project.find(6).parent

361

p = Project.find(6).parent

362

assert p.is_a?(Project)

362

assert p.is_a?(Project)

363

assert_equal 5, p.id

363

assert_equal 5, p.id

364

end

364

end

365

366

def test_ancestors

366

def test_ancestors

367

a = Project.find(6).ancestors

367

a = Project.find(6).ancestors

368

assert a.first.is_a?(Project)

368

assert a.first.is_a?(Project)

369

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

369

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

370

end

370

end

371

372

def test_root

372

def test_root

373

r = Project.find(6).root

373

r = Project.find(6).root

374

assert r.is_a?(Project)

374

assert r.is_a?(Project)

375

assert_equal 1, r.id

375

assert_equal 1, r.id

376

end

376

end

377

378

def test_children

378

def test_children

379

c = Project.find(1).children

379

c = Project.find(1).children

380

assert c.first.is_a?(Project)

380

assert c.first.is_a?(Project)

381

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

381

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

382

end

382

end

383

384

def test_descendants

384

def test_descendants

385

d = Project.find(1).descendants

385

d = Project.find(1).descendants

386

assert d.first.is_a?(Project)

386

assert d.first.is_a?(Project)

387

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

387

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

388

end

388

end

389

390

def test_allowed_parents_should_be_empty_for_non_member_user

390

def test_allowed_parents_should_be_empty_for_non_member_user

391

Role.non_member.add_permission!(:add_project)

391

Role.non_member.add_permission!(:add_project)

392

user = User.find(9)

392

user = User.find(9)

393

assert user.memberships.empty?

393

assert user.memberships.empty?

394

User.current = user

394

User.current = user

395

assert Project.new.allowed_parents.compact.empty?

395

assert Project.new.allowed_parents.compact.empty?

396

end

396

end

397

398

def test_allowed_parents_with_add_subprojects_permission

398

def test_allowed_parents_with_add_subprojects_permission

399

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

399

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

400

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

400

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

401

User.current = User.find(2)

401

User.current = User.find(2)

402

# new project

402

# new project

403

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

403

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

404

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

404

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

405

# existing root project

405

# existing root project

406

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

406

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

407

# existing child

407

# existing child

408

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

408

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

409

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

409

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

410

end

410

end

411

412

def test_allowed_parents_with_add_project_permission

412

def test_allowed_parents_with_add_project_permission

413

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

413

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

414

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

414

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

415

User.current = User.find(2)

415

User.current = User.find(2)

416

# new project

416

# new project

417

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

417

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

418

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

418

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

419

# existing root project

419

# existing root project

420

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

420

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

421

# existing child

421

# existing child

422

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

422

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

423

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

423

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

424

end

424

end

425

426

def test_allowed_parents_with_add_project_and_subprojects_permission

426

def test_allowed_parents_with_add_project_and_subprojects_permission

427

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

427

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

428

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

428

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

429

User.current = User.find(2)

429

User.current = User.find(2)

430

# new project

430

# new project

431

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

431

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

432

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

432

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

433

# existing root project

433

# existing root project

434

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

434

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

435

# existing child

435

# existing child

436

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

436

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

437

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

437

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

438

end

438

end

439

440

def test_users_by_role

440

def test_users_by_role

441

users_by_role = Project.find(1).users_by_role

441

users_by_role = Project.find(1).users_by_role

442

assert_kind_of Hash, users_by_role

442

assert_kind_of Hash, users_by_role

443

role = Role.find(1)

443

role = Role.find(1)

444

assert_kind_of Array, users_by_role[role]

444

assert_kind_of Array, users_by_role[role]

445

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

445

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

446

end

446

end

447

448

def test_rolled_up_trackers

448

def test_rolled_up_trackers

449

parent = Project.find(1)

449

parent = Project.find(1)

450

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

450

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

451

child = parent.children.find(3)

451

child = parent.children.find(3)

452

453

assert_equal [1, 2], parent.tracker_ids

453

assert_equal [1, 2], parent.tracker_ids

454

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

454

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

455

456

assert_kind_of Tracker, parent.rolled_up_trackers.first

456

assert_kind_of Tracker, parent.rolled_up_trackers.first

457

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

457

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

458

459

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

459

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

460

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

460

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

461

end

461

end

462

463

def test_rolled_up_trackers_should_ignore_archived_subprojects

463

def test_rolled_up_trackers_should_ignore_archived_subprojects

464

parent = Project.find(1)

464

parent = Project.find(1)

465

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

465

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

466

child = parent.children.find(3)

466

child = parent.children.find(3)

467

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

467

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

468

parent.children.each(&:archive)

468

parent.children.each(&:archive)

469

470

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

470

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

471

end

471

end

472

473

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

473

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

474

parent = Project.generate!

474

parent = Project.generate!

475

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

475

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

476

child = Project.generate_with_parent!(parent)

476

child = Project.generate_with_parent!(parent)

477

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

477

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

478

479

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

479

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

480

481

assert child.disable_module!(:issue_tracking)

481

assert child.disable_module!(:issue_tracking)

482

parent.reload

482

parent.reload

483

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

483

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

484

end

484

end

485

486

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

486

test "#rolled_up_versions should include the versions for the current project" 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

assert_equal [parent_version_1, parent_version_2].sort,

490

assert_equal [parent_version_1, parent_version_2].sort,

491

project.rolled_up_versions.sort

491

project.rolled_up_versions.sort

492

end

492

end

493

494

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

494

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

495

project = Project.generate!

495

project = Project.generate!

496

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

496

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

497

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

497

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

498

subproject = Project.generate_with_parent!(project)

498

subproject = Project.generate_with_parent!(project)

499

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

499

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

500

501

assert_equal [parent_version_1, parent_version_2, subproject_version].sort,

501

assert_equal [parent_version_1, parent_version_2, subproject_version].sort,

502

project.rolled_up_versions.sort

502

project.rolled_up_versions.sort

503

end

503

end

504

505

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

505

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

506

project = Project.generate!

506

project = Project.generate!

507

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

507

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

508

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

508

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

509

subproject = Project.generate_with_parent!(project)

509

subproject = Project.generate_with_parent!(project)

510

sub_subproject = Project.generate_with_parent!(subproject)

510

sub_subproject = Project.generate_with_parent!(subproject)

511

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

511

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

512

project.reload

512

project.reload

513

514

assert_equal [parent_version_1, parent_version_2, sub_subproject_version].sort,

514

assert_equal [parent_version_1, parent_version_2, sub_subproject_version].sort,

515

project.rolled_up_versions.sort

515

project.rolled_up_versions.sort

516

end

516

end

517

518

test "#rolled_up_versions should only check active projects" do

518

test "#rolled_up_versions should only check active projects" do

519

project = Project.generate!

519

project = Project.generate!

520

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

520

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

521

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

521

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

522

subproject = Project.generate_with_parent!(project)

522

subproject = Project.generate_with_parent!(project)

523

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

523

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

524

assert subproject.archive

524

assert subproject.archive

525

project.reload

525

project.reload

526

527

assert !subproject.active?

527

assert !subproject.active?

528

assert_equal [parent_version_1, parent_version_2].sort,

528

assert_equal [parent_version_1, parent_version_2].sort,

529

project.rolled_up_versions.sort

529

project.rolled_up_versions.sort

530

end

530

end

531

532

def test_shared_versions_none_sharing

532

def test_shared_versions_none_sharing

533

p = Project.find(5)

533

p = Project.find(5)

534

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

534

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

535

assert p.shared_versions.include?(v)

535

assert p.shared_versions.include?(v)

536

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

536

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

537

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

537

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

538

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

538

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

539

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

539

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

540

end

540

end

541

542

def test_shared_versions_descendants_sharing

542

def test_shared_versions_descendants_sharing

543

p = Project.find(5)

543

p = Project.find(5)

544

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

544

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

545

assert p.shared_versions.include?(v)

545

assert p.shared_versions.include?(v)

546

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

546

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

547

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

547

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

548

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

548

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

549

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

549

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

550

end

550

end

551

552

def test_shared_versions_hierarchy_sharing

552

def test_shared_versions_hierarchy_sharing

553

p = Project.find(5)

553

p = Project.find(5)

554

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

554

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

555

assert p.shared_versions.include?(v)

555

assert p.shared_versions.include?(v)

556

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

556

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

557

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

557

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

558

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

558

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

559

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

559

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

560

end

560

end

561

562

def test_shared_versions_tree_sharing

562

def test_shared_versions_tree_sharing

563

p = Project.find(5)

563

p = Project.find(5)

564

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

564

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

565

assert p.shared_versions.include?(v)

565

assert p.shared_versions.include?(v)

566

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

566

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

567

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

567

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

568

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

568

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

569

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

569

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

570

end

570

end

571

572

def test_shared_versions_system_sharing

572

def test_shared_versions_system_sharing

573

p = Project.find(5)

573

p = Project.find(5)

574

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

574

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

575

assert p.shared_versions.include?(v)

575

assert p.shared_versions.include?(v)

576

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

576

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

577

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

577

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

578

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

578

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

579

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

579

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

580

end

580

end

581

582

def test_shared_versions

582

def test_shared_versions

583

parent = Project.find(1)

583

parent = Project.find(1)

584

child = parent.children.find(3)

584

child = parent.children.find(3)

585

private_child = parent.children.find(5)

585

private_child = parent.children.find(5)

586

587

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

587

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

588

assert_equal [4], child.version_ids

588

assert_equal [4], child.version_ids

589

assert_equal [6], private_child.version_ids

589

assert_equal [6], private_child.version_ids

590

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

590

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

591

592

assert_equal 6, parent.shared_versions.size

592

assert_equal 6, parent.shared_versions.size

593

parent.shared_versions.each do |version|

593

parent.shared_versions.each do |version|

594

assert_kind_of Version, version

594

assert_kind_of Version, version

595

end

595

end

596

597

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

597

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

598

end

598

end

599

600

def test_shared_versions_should_ignore_archived_subprojects

600

def test_shared_versions_should_ignore_archived_subprojects

601

parent = Project.find(1)

601

parent = Project.find(1)

602

child = parent.children.find(3)

602

child = parent.children.find(3)

603

child.archive

603

child.archive

604

parent.reload

604

parent.reload

605

606

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

606

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

607

assert_equal [4], child.version_ids

607

assert_equal [4], child.version_ids

608

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

608

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

609

end

609

end

610

611

def test_shared_versions_visible_to_user

611

def test_shared_versions_visible_to_user

612

user = User.find(3)

612

user = User.find(3)

613

parent = Project.find(1)

613

parent = Project.find(1)

614

child = parent.children.find(5)

614

child = parent.children.find(5)

615

616

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

616

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

617

assert_equal [6], child.version_ids

617

assert_equal [6], child.version_ids

618

619

versions = parent.shared_versions.visible(user)

619

versions = parent.shared_versions.visible(user)

620

621

assert_equal 4, versions.size

621

assert_equal 4, versions.size

622

versions.each do |version|

622

versions.each do |version|

623

assert_kind_of Version, version

623

assert_kind_of Version, version

624

end

624

end

625

626

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

626

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

627

end

627

end

628

629

def test_shared_versions_for_new_project_should_include_system_shared_versions

629

def test_shared_versions_for_new_project_should_include_system_shared_versions

630

p = Project.find(5)

630

p = Project.find(5)

631

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

631

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

632

633

assert_include v, Project.new.shared_versions

633

assert_include v, Project.new.shared_versions

634

end

634

end

635

636

def test_next_identifier

636

def test_next_identifier

637

ProjectCustomField.delete_all

637

ProjectCustomField.delete_all

638

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

638

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

639

assert_equal 'p2008041', Project.next_identifier

639

assert_equal 'p2008041', Project.next_identifier

640

end

640

end

641

642

def test_next_identifier_first_project

642

def test_next_identifier_first_project

643

Project.delete_all

643

Project.delete_all

644

assert_nil Project.next_identifier

644

assert_nil Project.next_identifier

645

end

645

end

646

647

def test_enabled_module_names

647

def test_enabled_module_names

648

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

648

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

649

project = Project.new

649

project = Project.new

650

651

project.enabled_module_names = %w(issue_tracking news)

651

project.enabled_module_names = %w(issue_tracking news)

652

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

652

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

653

end

653

end

654

end

654

end

655

656

def test_enabled_modules_names_with_nil_should_clear_modules

656

def test_enabled_modules_names_with_nil_should_clear_modules

657

p = Project.find(1)

657

p = Project.find(1)

658

p.enabled_module_names = nil

658

p.enabled_module_names = nil

659

assert_equal [], p.enabled_modules

659

assert_equal [], p.enabled_modules

660

end

660

end

661

662

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

662

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

663

@project = Project.find(1)

663

@project = Project.find(1)

664

# Remove one module

664

# Remove one module

665

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

665

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

666

assert modules.any?

666

assert modules.any?

667

assert_difference 'EnabledModule.count', -1 do

667

assert_difference 'EnabledModule.count', -1 do

668

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

668

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

669

end

669

end

670

@project.reload

670

@project.reload

671

# Ids should be preserved

671

# Ids should be preserved

672

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

672

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

673

end

673

end

674

675

test "enabled_modules should enable a module" do

675

test "enabled_modules should enable a module" do

676

@project = Project.find(1)

676

@project = Project.find(1)

677

@project.enabled_module_names = []

677

@project.enabled_module_names = []

678

@project.reload

678

@project.reload

679

assert_equal [], @project.enabled_module_names

679

assert_equal [], @project.enabled_module_names

680

#with string

680

#with string

681

@project.enable_module!("issue_tracking")

681

@project.enable_module!("issue_tracking")

682

assert_equal ["issue_tracking"], @project.enabled_module_names

682

assert_equal ["issue_tracking"], @project.enabled_module_names

683

#with symbol

683

#with symbol

684

@project.enable_module!(:gantt)

684

@project.enable_module!(:gantt)

685

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

685

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

686

#don't add a module twice

686

#don't add a module twice

687

@project.enable_module!("issue_tracking")

687

@project.enable_module!("issue_tracking")

688

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

688

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

689

end

689

end

690

691

test "enabled_modules should disable a module" do

691

test "enabled_modules should disable a module" do

692

@project = Project.find(1)

692

@project = Project.find(1)

693

#with string

693

#with string

694

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

694

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

695

@project.disable_module!("issue_tracking")

695

@project.disable_module!("issue_tracking")

696

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

696

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

697

#with symbol

697

#with symbol

698

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

698

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

699

@project.disable_module!(:gantt)

699

@project.disable_module!(:gantt)

700

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

700

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

701

#with EnabledModule object

701

#with EnabledModule object

702

first_module = @project.enabled_modules.first

702

first_module = @project.enabled_modules.first

703

@project.disable_module!(first_module)

703

@project.disable_module!(first_module)

704

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

704

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

705

end

705

end

706

707

def test_enabled_module_names_should_not_recreate_enabled_modules

707

def test_enabled_module_names_should_not_recreate_enabled_modules

708

project = Project.find(1)

708

project = Project.find(1)

709

# Remove one module

709

# Remove one module

710

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

710

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

711

assert modules.any?

711

assert modules.any?

712

assert_difference 'EnabledModule.count', -1 do

712

assert_difference 'EnabledModule.count', -1 do

713

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

713

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

714

end

714

end

715

project.reload

715

project.reload

716

# Ids should be preserved

716

# Ids should be preserved

717

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

717

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

718

end

718

end

719

720

def test_copy_from_existing_project

720

def test_copy_from_existing_project

721

source_project = Project.find(1)

721

source_project = Project.find(1)

722

copied_project = Project.copy_from(1)

722

copied_project = Project.copy_from(1)

723

724

assert copied_project

724

assert copied_project

725

# Cleared attributes

725

# Cleared attributes

726

assert copied_project.id.blank?

726

assert copied_project.id.blank?

727

assert copied_project.name.blank?

727

assert copied_project.name.blank?

728

assert copied_project.identifier.blank?

728

assert copied_project.identifier.blank?

729

730

# Duplicated attributes

730

# Duplicated attributes

731

assert_equal source_project.description, copied_project.description

731

assert_equal source_project.description, copied_project.description

732

assert_equal source_project.trackers, copied_project.trackers

732

assert_equal source_project.trackers, copied_project.trackers

733

734

# Default attributes

734

# Default attributes

735

assert_equal 1, copied_project.status

735

assert_equal 1, copied_project.status

736

end

736

end

737

738

def test_copy_from_should_copy_enabled_modules

738

def test_copy_from_should_copy_enabled_modules

739

source = Project.generate!

739

source = Project.generate!

740

source.enabled_module_names = %w(issue_tracking wiki)

740

source.enabled_module_names = %w(issue_tracking wiki)

741

742

copy = Project.copy_from(source)

742

copy = Project.copy_from(source)

743

copy.name = 'Copy'

743

copy.name = 'Copy'

744

copy.identifier = 'copy'

744

copy.identifier = 'copy'

745

assert_difference 'EnabledModule.count', 2 do

745

assert_difference 'EnabledModule.count', 2 do

746

copy.save!

746

copy.save!

747

end

747

end

748

assert_equal 2, copy.reload.enabled_modules.count

748

assert_equal 2, copy.reload.enabled_modules.count

749

assert_equal 2, source.reload.enabled_modules.count

749

assert_equal 2, source.reload.enabled_modules.count

750

end

750

end

751

752

def test_activities_should_use_the_system_activities

752

def test_activities_should_use_the_system_activities

753

project = Project.find(1)

753

project = Project.find(1)

754

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

754

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

755

assert_kind_of ActiveRecord::Relation, project.activities

755

assert_kind_of ActiveRecord::Relation, project.activities

756

end

756

end

757

758

759

def test_activities_should_use_the_project_specific_activities

759

def test_activities_should_use_the_project_specific_activities

760

project = Project.find(1)

760

project = Project.find(1)

761

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

761

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

762

assert overridden_activity.save!

762

assert overridden_activity.save!

763

764

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

764

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

765

assert_kind_of ActiveRecord::Relation, project.activities

765

assert_kind_of ActiveRecord::Relation, project.activities

766

end

766

end

767

768

def test_activities_should_not_include_the_inactive_project_specific_activities

768

def test_activities_should_not_include_the_inactive_project_specific_activities

769

project = Project.find(1)

769

project = Project.find(1)

770

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

770

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

771

assert overridden_activity.save!

771

assert overridden_activity.save!

772

773

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

773

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

774

end

774

end

775

776

def test_activities_should_not_include_project_specific_activities_from_other_projects

776

def test_activities_should_not_include_project_specific_activities_from_other_projects

777

project = Project.find(1)

777

project = Project.find(1)

778

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

778

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

779

assert overridden_activity.save!

779

assert overridden_activity.save!

780

781

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

781

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

782

end

782

end

783

784

def test_activities_should_handle_nils

784

def test_activities_should_handle_nils

785

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

785

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

786

TimeEntryActivity.delete_all

786

TimeEntryActivity.delete_all

787

788

# No activities

788

# No activities

789

project = Project.find(1)

789

project = Project.find(1)

790

assert project.activities.empty?

790

assert project.activities.empty?

791

792

# No system, one overridden

792

# No system, one overridden

793

assert overridden_activity.save!

793

assert overridden_activity.save!

794

project.reload

794

project.reload

795

assert_equal [overridden_activity], project.activities

795

assert_equal [overridden_activity], project.activities

796

end

796

end

797

798

def test_activities_should_override_system_activities_with_project_activities

798

def test_activities_should_override_system_activities_with_project_activities

799

project = Project.find(1)

799

project = Project.find(1)

800

parent_activity = TimeEntryActivity.first

800

parent_activity = TimeEntryActivity.first

801

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

801

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

802

assert overridden_activity.save!

802

assert overridden_activity.save!

803

804

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

804

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

805

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

805

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

806

end

806

end

807

808

def test_activities_should_include_inactive_activities_if_specified

808

def test_activities_should_include_inactive_activities_if_specified

809

project = Project.find(1)

809

project = Project.find(1)

810

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

810

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

811

assert overridden_activity.save!

811

assert overridden_activity.save!

812

813

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

813

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

814

end

814

end

815

816

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

816

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

817

project = Project.find(1)

817

project = Project.find(1)

818

system_activity = TimeEntryActivity.find_by_name('Design')

818

system_activity = TimeEntryActivity.find_by_name('Design')

819

assert system_activity.active?

819

assert system_activity.active?

820

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

820

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

821

assert overridden_activity.save!

821

assert overridden_activity.save!

822

823

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

823

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

824

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

824

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

825

end

825

end

826

827

def test_close_completed_versions

827

def test_close_completed_versions

828

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

828

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

829

project = Project.find(1)

829

project = Project.find(1)

830

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

830

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

831

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

831

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

832

project.close_completed_versions

832

project.close_completed_versions

833

project.reload

833

project.reload

834

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

834

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

835

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

835

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

836

end

836

end

837

838

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

838

test "#start_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.start_date

840

assert_nil project.start_date

841

end

841

end

842

843

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

843

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

844

project = Project.generate!

844

project = Project.generate!

845

project.trackers << Tracker.generate!

845

project.trackers << Tracker.generate!

846

early = 7.days.ago.to_date

846

early = 7.days.ago.to_date

847

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

847

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

848

849

assert_nil project.start_date

849

assert_nil project.start_date

850

end

850

end

851

852

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

852

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

853

project = Project.generate!

853

project = Project.generate!

854

project.trackers << Tracker.generate!

854

project.trackers << Tracker.generate!

855

early = 7.days.ago.to_date

855

early = 7.days.ago.to_date

856

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

856

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

857

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

857

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

858

859

assert_equal early, project.start_date

859

assert_equal early, project.start_date

860

end

860

end

861

862

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

862

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

863

project = Project.generate!

863

project = Project.generate!

864

assert_nil project.due_date

864

assert_nil project.due_date

865

end

865

end

866

867

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

867

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

868

project = Project.generate!

868

project = Project.generate!

869

project.trackers << Tracker.generate!

869

project.trackers << Tracker.generate!

870

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

870

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

871

872

assert_nil project.due_date

872

assert_nil project.due_date

873

end

873

end

874

875

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

875

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

876

project = Project.generate!

876

project = Project.generate!

877

project.trackers << Tracker.generate!

877

project.trackers << Tracker.generate!

878

future = 7.days.from_now.to_date

878

future = 7.days.from_now.to_date

879

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

879

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

880

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

880

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

881

882

assert_equal future, project.due_date

882

assert_equal future, project.due_date

883

end

883

end

884

885

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

885

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

886

project = Project.generate!

886

project = Project.generate!

887

future = 7.days.from_now.to_date

887

future = 7.days.from_now.to_date

888

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

888

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

889

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

889

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

890

891

assert_equal future, project.due_date

891

assert_equal future, project.due_date

892

end

892

end

893

894

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

894

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

895

project = Project.generate!

895

project = Project.generate!

896

project.trackers << Tracker.generate!

896

project.trackers << Tracker.generate!

897

future = 7.days.from_now.to_date

897

future = 7.days.from_now.to_date

898

far_future = 14.days.from_now.to_date

898

far_future = 14.days.from_now.to_date

899

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

899

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

900

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

900

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

901

902

assert_equal far_future, project.due_date

902

assert_equal far_future, project.due_date

903

end

903

end

904

905

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

905

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

906

project = Project.generate!

906

project = Project.generate!

907

assert_equal 100, project.completed_percent

907

assert_equal 100, project.completed_percent

908

end

908

end

909

910

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

910

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

911

project = Project.generate!

911

project = Project.generate!

912

Version.generate!(:project => project)

912

Version.generate!(:project => project)

913

Version.generate!(:project => project)

913

Version.generate!(:project => project)

914

915

assert_equal 0, project.completed_percent

915

assert_equal 0, project.completed_percent

916

end

916

end

917

918

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

918

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

919

project = Project.generate!

919

project = Project.generate!

920

project.trackers << Tracker.generate!

920

project.trackers << Tracker.generate!

921

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

921

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

922

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

922

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

923

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

923

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

924

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

924

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

925

926

assert_equal 100, project.completed_percent

926

assert_equal 100, project.completed_percent

927

end

927

end

928

929

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

929

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

930

project = Project.generate!

930

project = Project.generate!

931

project.trackers << Tracker.generate!

931

project.trackers << Tracker.generate!

932

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

932

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

933

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

933

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

934

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

934

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

935

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

935

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

936

937

assert_equal 50, project.completed_percent

937

assert_equal 50, project.completed_percent

938

end

938

end

939

940

test "#notified_users" do

940

test "#notified_users" do

941

project = Project.generate!

941

project = Project.generate!

942

role = Role.generate!

942

role = Role.generate!

943

944

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

944

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

945

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

945

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

946

947

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

947

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

948

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

948

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

949

950

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

950

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

951

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

951

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

952

953

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

953

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

954

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

954

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

955

956

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

956

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

957

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

957

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

958

959

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

959

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

960

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

960

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

961

962

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

962

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

963

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

963

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

964

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

964

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

965

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

965

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

966

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

966

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

967

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

967

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

968

end

968

end

969

970

def test_override_roles_without_builtin_group_memberships

970

def test_override_roles_without_builtin_group_memberships

971

project = Project.generate!

971

project = Project.generate!

972

assert_equal [Role.anonymous], project.override_roles(Role.anonymous)

972

assert_equal [Role.anonymous], project.override_roles(Role.anonymous)

973

assert_equal [Role.non_member], project.override_roles(Role.non_member)

973

assert_equal [Role.non_member], project.override_roles(Role.non_member)

974

end

974

end

975

976

def test_css_classes

976

def test_css_classes

977

p = Project.new

977

p = Project.new

978

assert_kind_of String, p.css_classes

978

assert_kind_of String, p.css_classes

979

assert_not_include 'archived', p.css_classes.split

979

assert_not_include 'archived', p.css_classes.split

980

assert_not_include 'closed', p.css_classes.split

980

assert_not_include 'closed', p.css_classes.split

981

end

981

end

982

983

def test_css_classes_for_archived_project

983

def test_css_classes_for_archived_project

984

p = Project.new

984

p = Project.new

985

p.status = Project::STATUS_ARCHIVED

985

p.status = Project::STATUS_ARCHIVED

986

assert_include 'archived', p.css_classes.split

986

assert_include 'archived', p.css_classes.split

987

end

987

end

988

989

def test_css_classes_for_closed_project

989

def test_css_classes_for_closed_project

990

p = Project.new

990

p = Project.new

991

p.status = Project::STATUS_CLOSED

991

p.status = Project::STATUS_CLOSED

992

assert_include 'closed', p.css_classes.split

992

assert_include 'closed', p.css_classes.split

993

end

993

end

994

995

def test_combination_of_visible_and_uniq_scopes_in_case_anonymous_group_has_memberships_should_not_error

996

project = Project.find(1)

997

member = Member.create!(:project => project, :principal => Group.anonymous, :roles => [Role.generate!])

998

project.members << member

999

assert_nothing_raised do

1000

Project.uniq.visible.to_a

1001

end

1002

end

994

end

1003

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-2015  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.
             class Principal < ActiveRecord::Base
               self.table_name = "#{table_name_prefix}users#{table_name_suffix}"
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               has_many :members, :foreign_key => 'user_id', :dependent => :destroy
               has_many :memberships,
                        lambda {preload(:project, :roles).
                                joins(:project).
-                               where("#{Project.table_name}.status<>#{Project::STATUS_ARCHIVED}").
+                               where("#{Project.table_name}.status<>#{Project::STATUS_ARCHIVED}")},
-                               order("#{Project.table_name}.name")},
                        :class_name => 'Member',
                        :foreign_key => 'user_id'
               has_many :projects, :through => :memberships
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               # Groups and active users
               scope :active, lambda { where(:status => STATUS_ACTIVE) }
               scope :visible, lambda {|*args|
                 user = args.first || User.current
                 if user.admin?
                   all
                 else
                   view_all_active = false
                   if user.memberships.to_a.any?
                     view_all_active = user.memberships.any? {|m| m.roles.any? {|r| r.users_visibility == 'all'}}
                   else
                     view_all_active = user.builtin_role.users_visibility == 'all'
                   end
                   if view_all_active
                     active
                   else
                     # self and members of visible projects
                     active.where("#{table_name}.id = ? OR #{table_name}.id IN (SELECT user_id FROM #{Member.table_name} WHERE project_id IN (?))",
                       user.id, user.visible_project_ids
                     )
                   end
                 end
               }
               scope :like, lambda {|q|
                 q = q.to_s
                 if q.blank?
                   where({})
                 else
                   pattern = "%#{q}%"
                   sql = %w(login firstname lastname).map {|column| "LOWER(#{table_name}.#{column}) LIKE LOWER(:p)"}.join(" OR ")
                   sql << " OR #{table_name}.id IN (SELECT user_id FROM #{EmailAddress.table_name} WHERE LOWER(address) LIKE LOWER(:p))"
                   params = {:p => pattern}
                   if q =~ /^(.+)\s+(.+)$/
                     a, b = "#{$1}%", "#{$2}%"
                     sql << " OR (LOWER(#{table_name}.firstname) LIKE LOWER(:a) AND LOWER(#{table_name}.lastname) LIKE LOWER(:b))"
                     sql << " OR (LOWER(#{table_name}.firstname) LIKE LOWER(:b) AND LOWER(#{table_name}.lastname) LIKE LOWER(:a))"
                     params.merge!(:a => a, :b => b)
                   end
                   where(sql, params)
                 end
               }
               # Principals that are members of a collection of projects
               scope :member_of, lambda {|projects|
                 projects = [projects] if projects.is_a?(Project)
                 if projects.blank?
                   where("1=0")
                 else
                   ids = projects.map(&:id)
                   active.where("#{Principal.table_name}.id IN (SELECT DISTINCT user_id FROM #{Member.table_name} WHERE project_id IN (?))", ids)
                 end
               }
               # Principals that are not members of projects
               scope :not_member_of, lambda {|projects|
                 projects = [projects] unless projects.is_a?(Array)
                 if projects.empty?
                   where("1=0")
                 else
                   ids = projects.map(&:id)
                   where("#{Principal.table_name}.id NOT IN (SELECT DISTINCT user_id FROM #{Member.table_name} WHERE project_id IN (?))", ids)
                 end
               }
               scope :sorted, lambda { order(*Principal.fields_for_order_statement)}
               before_create :set_default_empty_values
               def name(formatter = nil)
                 to_s
               end
               def mail=(*args)
                 nil
               end
               def mail
                 nil
               end
               def visible?(user=User.current)
                 Principal.visible(user).where(:id => id).first == self
               end
               # Return true if the principal is a member of project
               def member_of?(project)
                 projects.to_a.include?(project)
               end
               def <=>(principal)
                 if principal.nil?
                   -1
                 elsif self.class.name == principal.class.name
                   self.to_s.casecmp(principal.to_s)
                 else
                   # groups after users
                   principal.class.name <=> self.class.name
                 end
               end
               # Returns an array of fields names than can be used to make an order statement for principals.
               # Users are sorted before Groups.
               # Examples:
               def self.fields_for_order_statement(table=nil)
                 table ||= table_name
                 columns = ['type DESC'] + (User.name_formatter[:order] - ['id']) + ['lastname', 'id']
                 columns.uniq.map {|field| "#{table}.#{field}"}
               end
               # Returns the principal that matches the keyword among principals
               def self.detect_by_keyword(principals, keyword)
                 keyword = keyword.to_s
                 return nil if keyword.blank?
                 principal = nil
                 principal ||= principals.detect {|a| keyword.casecmp(a.login.to_s) == 0}
                 principal ||= principals.detect {|a| keyword.casecmp(a.mail.to_s) == 0}
                 if principal.nil? && keyword.match(/ /)
                   firstname, lastname = *(keyword.split) # "First Last Throwaway"
                   principal ||= principals.detect {|a|
                                              a.is_a?(User) &&
                                                firstname.casecmp(a.firstname.to_s) == 0 &&
                                                lastname.casecmp(a.lastname.to_s) == 0
                                            }
                 end
                 if principal.nil?
                   principal ||= principals.detect {|a| keyword.casecmp(a.name) == 0}
                 end
                 principal
               end
               protected
               # Make sure we don't try to insert NULL values (see #4632)
               def set_default_empty_values
                 self.login ||= ''
                 self.hashed_password ||= ''
                 self.firstname ||= ''
                 self.lastname ||= ''
                 true
               end
             end
             require_dependency "user"
             require_dependency "group"

             # Redmine - project management software
             # Copyright (C) 2006-2015  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,
                        :workflows
               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_to_param_should_be_nil_for_new_records
                 project = Project.new
                 project.identifier = "foo"
                 assert_nil project.to_param
               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).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_equal 0, Issue.where(:id => issues.map(&:id)).count
               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.sort_by(&:name), parent.children.to_a
               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_equal [parent_version_1, parent_version_2].sort,
                   project.rolled_up_versions.sort
               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_equal [parent_version_1, parent_version_2, subproject_version].sort,
                   project.rolled_up_versions.sort
               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_equal [parent_version_1, parent_version_2, sub_subproject_version].sort,
                   project.rolled_up_versions.sort
               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_equal [parent_version_1, parent_version_2].sort,
                   project.rolled_up_versions.sort
               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').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
               def test_enabled_modules_names_with_nil_should_clear_modules
                 p = Project.find(1)
                 p.enabled_module_names = nil
                 assert_equal [], p.enabled_modules
               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.trackers, copied_project.trackers
                 # Default attributes
                 assert_equal 1, copied_project.status
               end
               def test_copy_from_should_copy_enabled_modules
                 source = Project.generate!
                 source.enabled_module_names = %w(issue_tracking wiki)
                 copy = Project.copy_from(source)
                 copy.name = 'Copy'
                 copy.identifier = 'copy'
                 assert_difference 'EnabledModule.count', 2 do
                   copy.save!
                 end
                 assert_equal 2, copy.reload.enabled_modules.count
                 assert_equal 2, source.reload.enabled_modules.count
               end
               def test_activities_should_use_the_system_activities
                 project = Project.find(1)
                 assert_equal project.activities.to_a, TimeEntryActivity.where(:active => true).to_a
                 assert_kind_of ActiveRecord::Relation, project.activities
               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"
                 assert_kind_of ActiveRecord::Relation, project.activities
               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
               def test_override_roles_without_builtin_group_memberships
                 project = Project.generate!
                 assert_equal [Role.anonymous], project.override_roles(Role.anonymous)
                 assert_equal [Role.non_member], project.override_roles(Role.non_member)
               end
               def test_css_classes
                 p = Project.new
                 assert_kind_of String, p.css_classes
                 assert_not_include 'archived', p.css_classes.split
                 assert_not_include 'closed', p.css_classes.split
               end
               def test_css_classes_for_archived_project
                 p = Project.new
                 p.status = Project::STATUS_ARCHIVED
                 assert_include 'archived', p.css_classes.split
               end
               def test_css_classes_for_closed_project
                 p = Project.new
                 p.status = Project::STATUS_CLOSED
                 assert_include 'closed', p.css_classes.split
               end
+              def test_combination_of_visible_and_uniq_scopes_in_case_anonymous_group_has_memberships_should_not_error
+                project = Project.find(1)
+                member = Member.create!(:project => project, :principal => Group.anonymous, :roles => [Role.generate!])
+                project.members << member
+                assert_nothing_raised do
+                  Project.uniq.visible.to_a
+                end
+              end
             end