jro_apps/redmine Commit - r13327:56edfcf6e92c

1

# encoding: utf-8

1

# encoding: utf-8

2

#

2

#

3

# Redmine - project management software

3

# Redmine - project management software

4

5

#

5

#

6

# This program is free software; you can redistribute it and/or

6

# This program is free software; you can redistribute it and/or

7

# modify it under the terms of the GNU General Public License

7

# modify it under the terms of the GNU General Public License

8

# as published by the Free Software Foundation; either version 2

8

# as published by the Free Software Foundation; either version 2

9

# of the License, or (at your option) any later version.

9

# of the License, or (at your option) any later version.

10

#

10

#

11

# This program is distributed in the hope that it will be useful,

11

# This program is distributed in the hope that it will be useful,

12

# but WITHOUT ANY WARRANTY; without even the implied warranty of

12

# but WITHOUT ANY WARRANTY; without even the implied warranty of

13

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

13

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

14

# GNU General Public License for more details.

14

# GNU General Public License for more details.

15

#

15

#

16

# You should have received a copy of the GNU General Public License

16

# You should have received a copy of the GNU General Public License

17

# along with this program; if not, write to the Free Software

17

# along with this program; if not, write to the Free Software

18

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

18

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

19

20

require File.expand_path('../../test_helper', __FILE__)

20

require File.expand_path('../../test_helper', __FILE__)

21

22

class AttachmentTest < ActiveSupport::TestCase

22

class AttachmentTest < ActiveSupport::TestCase

23

fixtures :users, :projects, :roles, :members, :member_roles,

23

fixtures :users, :projects, :roles, :members, :member_roles,

24

:enabled_modules, :issues, :trackers, :attachments

24

:enabled_modules, :issues, :trackers, :attachments

25

26

class MockFile

26

class MockFile

27

attr_reader :original_filename, :content_type, :content, :size

27

attr_reader :original_filename, :content_type, :content, :size

28

29

def initialize(attributes)

29

def initialize(attributes)

30

@original_filename = attributes[:original_filename]

30

@original_filename = attributes[:original_filename]

31

@content_type = attributes[:content_type]

31

@content_type = attributes[:content_type]

32

@content = attributes[:content] || "Content"

32

@content = attributes[:content] || "Content"

33

@size = content.size

33

@size = content.size

34

end

34

end

35

end

35

end

36

37

def setup

37

def setup

38

set_tmp_attachments_directory

38

set_tmp_attachments_directory

39

end

39

end

40

41

def test_container_for_new_attachment_should_be_nil

41

def test_container_for_new_attachment_should_be_nil

42

assert_nil Attachment.new.container

42

assert_nil Attachment.new.container

43

end

43

end

44

45

def test_filename_should_remove_eols

45

def test_filename_should_remove_eols

46

assert_equal "line_feed", Attachment.new(:filename => "line\nfeed").filename

46

assert_equal "line_feed", Attachment.new(:filename => "line\nfeed").filename

47

assert_equal "line_feed", Attachment.new(:filename => "some\npath/line\nfeed").filename

47

assert_equal "line_feed", Attachment.new(:filename => "some\npath/line\nfeed").filename

48

assert_equal "carriage_return", Attachment.new(:filename => "carriage\rreturn").filename

48

assert_equal "carriage_return", Attachment.new(:filename => "carriage\rreturn").filename

49

assert_equal "carriage_return", Attachment.new(:filename => "some\rpath/carriage\rreturn").filename

49

assert_equal "carriage_return", Attachment.new(:filename => "some\rpath/carriage\rreturn").filename

50

end

50

end

51

52

def test_create

52

def test_create

53

a = Attachment.new(:container => Issue.find(1),

53

a = Attachment.new(:container => Issue.find(1),

54

:file => uploaded_test_file("testfile.txt", "text/plain"),

54

:file => uploaded_test_file("testfile.txt", "text/plain"),

55

:author => User.find(1))

55

:author => User.find(1))

56

assert a.save

56

assert a.save

57

assert_equal 'testfile.txt', a.filename

57

assert_equal 'testfile.txt', a.filename

58

assert_equal 59, a.filesize

58

assert_equal 59, a.filesize

59

assert_equal 'text/plain', a.content_type

59

assert_equal 'text/plain', a.content_type

60

assert_equal 0, a.downloads

60

assert_equal 0, a.downloads

61

assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest

61

assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest

62

63

assert a.disk_directory

63

assert a.disk_directory

64

assert_match %r{\A\d{4}/\d{2}\z}, a.disk_directory

64

assert_match %r{\A\d{4}/\d{2}\z}, a.disk_directory

65

66

assert File.exist?(a.diskfile)

66

assert File.exist?(a.diskfile)

67

assert_equal 59, File.size(a.diskfile)

67

assert_equal 59, File.size(a.diskfile)

68

end

68

end

69

70

def test_create_should_clear_content_type_if_too_long

71

a = Attachment.new(:container => Issue.find(1),

72

:file => uploaded_test_file("testfile.txt", "text/plain"),

73

:author => User.find(1),

74

:content_type => 'a'*300)

75

assert a.save

76

a.reload

77

assert_nil a.content_type

78

end

79

70

def test_copy_should_preserve_attributes

80

def test_copy_should_preserve_attributes

71

a = Attachment.find(1)

81

a = Attachment.find(1)

72

copy = a.copy

82

copy = a.copy

73

83

74

assert_save copy

84

assert_save copy

75

copy = Attachment.order('id DESC').first

85

copy = Attachment.order('id DESC').first

76

%w(filename filesize content_type author_id created_on description digest disk_filename disk_directory diskfile).each do |attribute|

86

%w(filename filesize content_type author_id created_on description digest disk_filename disk_directory diskfile).each do |attribute|

77

assert_equal a.send(attribute), copy.send(attribute), "#{attribute} was different"

87

assert_equal a.send(attribute), copy.send(attribute), "#{attribute} was different"

78

end

88

end

79

end

89

end

80

90

81

def test_size_should_be_validated_for_new_file

91

def test_size_should_be_validated_for_new_file

82

with_settings :attachment_max_size => 0 do

92

with_settings :attachment_max_size => 0 do

83

a = Attachment.new(:container => Issue.find(1),

93

a = Attachment.new(:container => Issue.find(1),

84

:file => uploaded_test_file("testfile.txt", "text/plain"),

94

:file => uploaded_test_file("testfile.txt", "text/plain"),

85

:author => User.find(1))

95

:author => User.find(1))

86

assert !a.save

96

assert !a.save

87

end

97

end

88

end

98

end

89

99

90

def test_size_should_not_be_validated_when_copying

100

def test_size_should_not_be_validated_when_copying

91

a = Attachment.create!(:container => Issue.find(1),

101

a = Attachment.create!(:container => Issue.find(1),

92

:file => uploaded_test_file("testfile.txt", "text/plain"),

102

:file => uploaded_test_file("testfile.txt", "text/plain"),

93

:author => User.find(1))

103

:author => User.find(1))

94

with_settings :attachment_max_size => 0 do

104

with_settings :attachment_max_size => 0 do

95

copy = a.copy

105

copy = a.copy

96

assert copy.save

106

assert copy.save

97

end

107

end

98

end

108

end

99

109

100

def test_description_length_should_be_validated

110

def test_description_length_should_be_validated

101

a = Attachment.new(:description => 'a' * 300)

111

a = Attachment.new(:description => 'a' * 300)

102

assert !a.save

112

assert !a.save

103

assert_not_equal [], a.errors[:description]

113

assert_not_equal [], a.errors[:description]

104

end

114

end

105

115

106

def test_destroy

116

def test_destroy

107

a = Attachment.new(:container => Issue.find(1),

117

a = Attachment.new(:container => Issue.find(1),

108

:file => uploaded_test_file("testfile.txt", "text/plain"),

118

:file => uploaded_test_file("testfile.txt", "text/plain"),

109

:author => User.find(1))

119

:author => User.find(1))

110

assert a.save

120

assert a.save

111

assert_equal 'testfile.txt', a.filename

121

assert_equal 'testfile.txt', a.filename

112

assert_equal 59, a.filesize

122

assert_equal 59, a.filesize

113

assert_equal 'text/plain', a.content_type

123

assert_equal 'text/plain', a.content_type

114

assert_equal 0, a.downloads

124

assert_equal 0, a.downloads

115

assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest

125

assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest

116

diskfile = a.diskfile

126

diskfile = a.diskfile

117

assert File.exist?(diskfile)

127

assert File.exist?(diskfile)

118

assert_equal 59, File.size(a.diskfile)

128

assert_equal 59, File.size(a.diskfile)

119

assert a.destroy

129

assert a.destroy

120

assert !File.exist?(diskfile)

130

assert !File.exist?(diskfile)

121

end

131

end

122

132

123

def test_destroy_should_not_delete_file_referenced_by_other_attachment

133

def test_destroy_should_not_delete_file_referenced_by_other_attachment

124

a = Attachment.create!(:container => Issue.find(1),

134

a = Attachment.create!(:container => Issue.find(1),

125

:file => uploaded_test_file("testfile.txt", "text/plain"),

135

:file => uploaded_test_file("testfile.txt", "text/plain"),

126

:author => User.find(1))

136

:author => User.find(1))

127

diskfile = a.diskfile

137

diskfile = a.diskfile

128

138

129

copy = a.copy

139

copy = a.copy

130

copy.save!

140

copy.save!

131

141

132

assert File.exists?(diskfile)

142

assert File.exists?(diskfile)

133

a.destroy

143

a.destroy

134

assert File.exists?(diskfile)

144

assert File.exists?(diskfile)

135

copy.destroy

145

copy.destroy

136

assert !File.exists?(diskfile)

146

assert !File.exists?(diskfile)

137

end

147

end

138

148

139

def test_create_should_auto_assign_content_type

149

def test_create_should_auto_assign_content_type

140

a = Attachment.new(:container => Issue.find(1),

150

a = Attachment.new(:container => Issue.find(1),

141

:file => uploaded_test_file("testfile.txt", ""),

151

:file => uploaded_test_file("testfile.txt", ""),

142

:author => User.find(1))

152

:author => User.find(1))

143

assert a.save

153

assert a.save

144

assert_equal 'text/plain', a.content_type

154

assert_equal 'text/plain', a.content_type

145

end

155

end

146

156

147

def test_identical_attachments_at_the_same_time_should_not_overwrite

157

def test_identical_attachments_at_the_same_time_should_not_overwrite

148

a1 = Attachment.create!(:container => Issue.find(1),

158

a1 = Attachment.create!(:container => Issue.find(1),

149

:file => uploaded_test_file("testfile.txt", ""),

159

:file => uploaded_test_file("testfile.txt", ""),

150

:author => User.find(1))

160

:author => User.find(1))

151

a2 = Attachment.create!(:container => Issue.find(1),

161

a2 = Attachment.create!(:container => Issue.find(1),

152

:file => uploaded_test_file("testfile.txt", ""),

162

:file => uploaded_test_file("testfile.txt", ""),

153

:author => User.find(1))

163

:author => User.find(1))

154

assert a1.disk_filename != a2.disk_filename

164

assert a1.disk_filename != a2.disk_filename

155

end

165

end

156

166

157

def test_filename_should_be_basenamed

167

def test_filename_should_be_basenamed

158

a = Attachment.new(:file => MockFile.new(:original_filename => "path/to/the/file"))

168

a = Attachment.new(:file => MockFile.new(:original_filename => "path/to/the/file"))

159

assert_equal 'file', a.filename

169

assert_equal 'file', a.filename

160

end

170

end

161

171

162

def test_filename_should_be_sanitized

172

def test_filename_should_be_sanitized

163

a = Attachment.new(:file => MockFile.new(:original_filename => "valid:[] invalid:?%*|\"'<>chars"))

173

a = Attachment.new(:file => MockFile.new(:original_filename => "valid:[] invalid:?%*|\"'<>chars"))

164

assert_equal 'valid_[] invalid_chars', a.filename

174

assert_equal 'valid_[] invalid_chars', a.filename

165

end

175

end

166

176

167

def test_diskfilename

177

def test_diskfilename

168

assert Attachment.disk_filename("test_file.txt") =~ /^\d{12}_test_file.txt$/

178

assert Attachment.disk_filename("test_file.txt") =~ /^\d{12}_test_file.txt$/

169

assert_equal 'test_file.txt', Attachment.disk_filename("test_file.txt")[13..-1]

179

assert_equal 'test_file.txt', Attachment.disk_filename("test_file.txt")[13..-1]

170

assert_equal '770c509475505f37c2b8fb6030434d6b.txt', Attachment.disk_filename("test_accentué.txt")[13..-1]

180

assert_equal '770c509475505f37c2b8fb6030434d6b.txt', Attachment.disk_filename("test_accentué.txt")[13..-1]

171

assert_equal 'f8139524ebb8f32e51976982cd20a85d', Attachment.disk_filename("test_accentué")[13..-1]

181

assert_equal 'f8139524ebb8f32e51976982cd20a85d', Attachment.disk_filename("test_accentué")[13..-1]

172

assert_equal 'cbb5b0f30978ba03731d61f9f6d10011', Attachment.disk_filename("test_accentué.ça")[13..-1]

182

assert_equal 'cbb5b0f30978ba03731d61f9f6d10011', Attachment.disk_filename("test_accentué.ça")[13..-1]

173

end

183

end

174

184

175

def test_title

185

def test_title

176

a = Attachment.new(:filename => "test.png")

186

a = Attachment.new(:filename => "test.png")

177

assert_equal "test.png", a.title

187

assert_equal "test.png", a.title

178

188

179

a = Attachment.new(:filename => "test.png", :description => "Cool image")

189

a = Attachment.new(:filename => "test.png", :description => "Cool image")

180

assert_equal "test.png (Cool image)", a.title

190

assert_equal "test.png (Cool image)", a.title

181

end

191

end

182

192

193

def test_new_attachment_should_be_editable_by_authot

194

user = User.find(1)

195

a = Attachment.new(:author => user)

196

assert_equal true, a.editable?(user)

197

end

198

183

def test_prune_should_destroy_old_unattached_attachments

199

def test_prune_should_destroy_old_unattached_attachments

184

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

200

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

185

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

201

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

186

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)

202

Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)

187

203

188

assert_difference 'Attachment.count', -2 do

204

assert_difference 'Attachment.count', -2 do

189

Attachment.prune

205

Attachment.prune

190

end

206

end

191

end

207

end

192

208

193

def test_move_from_root_to_target_directory_should_move_root_files

209

def test_move_from_root_to_target_directory_should_move_root_files

194

a = Attachment.find(20)

210

a = Attachment.find(20)

195

assert a.disk_directory.blank?

211

assert a.disk_directory.blank?

196

# Create a real file for this fixture

212

# Create a real file for this fixture

197

File.open(a.diskfile, "w") do |f|

213

File.open(a.diskfile, "w") do |f|

198

f.write "test file at the root of files directory"

214

f.write "test file at the root of files directory"

199

end

215

end

200

assert a.readable?

216

assert a.readable?

201

Attachment.move_from_root_to_target_directory

217

Attachment.move_from_root_to_target_directory

202

218

203

a.reload

219

a.reload

204

assert_equal '2012/05', a.disk_directory

220

assert_equal '2012/05', a.disk_directory

205

assert a.readable?

221

assert a.readable?

206

end

222

end

207

223

208

test "Attachmnet.attach_files should attach the file" do

224

test "Attachmnet.attach_files should attach the file" do

209

issue = Issue.first

225

issue = Issue.first

210

assert_difference 'Attachment.count' do

226

assert_difference 'Attachment.count' do

211

Attachment.attach_files(issue,

227

Attachment.attach_files(issue,

212

'1' => {

228

'1' => {

213

'file' => uploaded_test_file('testfile.txt', 'text/plain'),

229

'file' => uploaded_test_file('testfile.txt', 'text/plain'),

214

'description' => 'test'

230

'description' => 'test'

215

})

231

})

216

end

232

end

217

attachment = Attachment.order('id DESC').first

233

attachment = Attachment.order('id DESC').first

218

assert_equal issue, attachment.container

234

assert_equal issue, attachment.container

219

assert_equal 'testfile.txt', attachment.filename

235

assert_equal 'testfile.txt', attachment.filename

220

assert_equal 59, attachment.filesize

236

assert_equal 59, attachment.filesize

221

assert_equal 'test', attachment.description

237

assert_equal 'test', attachment.description

222

assert_equal 'text/plain', attachment.content_type

238

assert_equal 'text/plain', attachment.content_type

223

assert File.exists?(attachment.diskfile)

239

assert File.exists?(attachment.diskfile)

224

assert_equal 59, File.size(attachment.diskfile)

240

assert_equal 59, File.size(attachment.diskfile)

225

end

241

end

226

242

227

test "Attachmnet.attach_files should add unsaved files to the object as unsaved attachments" do

243

test "Attachmnet.attach_files should add unsaved files to the object as unsaved attachments" do

228

# Max size of 0 to force Attachment creation failures

244

# Max size of 0 to force Attachment creation failures

229

with_settings(:attachment_max_size => 0) do

245

with_settings(:attachment_max_size => 0) do

230

@project = Project.find(1)

246

@project = Project.find(1)

231

response = Attachment.attach_files(@project, {

247

response = Attachment.attach_files(@project, {

232

'1' => {'file' => mock_file, 'description' => 'test'},

248

'1' => {'file' => mock_file, 'description' => 'test'},

233

'2' => {'file' => mock_file, 'description' => 'test'}

249

'2' => {'file' => mock_file, 'description' => 'test'}

234

})

250

})

235

251

236

assert response[:unsaved].present?

252

assert response[:unsaved].present?

237

assert_equal 2, response[:unsaved].length

253

assert_equal 2, response[:unsaved].length

238

assert response[:unsaved].first.new_record?

254

assert response[:unsaved].first.new_record?

239

assert response[:unsaved].second.new_record?

255

assert response[:unsaved].second.new_record?

240

assert_equal response[:unsaved], @project.unsaved_attachments

256

assert_equal response[:unsaved], @project.unsaved_attachments

241

end

257

end

242

end

258

end

243

259

244

test "Attachment.attach_files should preserve the content_type of attachments added by token" do

260

test "Attachment.attach_files should preserve the content_type of attachments added by token" do

245

@project = Project.find(1)

261

@project = Project.find(1)

246

attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

262

attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)

247

assert_equal 'text/plain', attachment.content_type

263

assert_equal 'text/plain', attachment.content_type

248

Attachment.attach_files(@project, { '1' => {'token' => attachment.token } })

264

Attachment.attach_files(@project, { '1' => {'token' => attachment.token } })

249

attachment.reload

265

attachment.reload

250

assert_equal 'text/plain', attachment.content_type

266

assert_equal 'text/plain', attachment.content_type

251

end

267

end

252

268

253

def test_update_attachments

269

def test_update_attachments

254

attachments = Attachment.where(:id => [2, 3]).to_a

270

attachments = Attachment.where(:id => [2, 3]).to_a

255

271

256

assert Attachment.update_attachments(attachments, {

272

assert Attachment.update_attachments(attachments, {

257

'2' => {:filename => 'newname.txt', :description => 'New description'},

273

'2' => {:filename => 'newname.txt', :description => 'New description'},

258

3 => {:filename => 'othername.txt'}

274

3 => {:filename => 'othername.txt'}

259

})

275

})

260

276

261

attachment = Attachment.find(2)

277

attachment = Attachment.find(2)

262

assert_equal 'newname.txt', attachment.filename

278

assert_equal 'newname.txt', attachment.filename

263

assert_equal 'New description', attachment.description

279

assert_equal 'New description', attachment.description

264

280

265

attachment = Attachment.find(3)

281

attachment = Attachment.find(3)

266

assert_equal 'othername.txt', attachment.filename

282

assert_equal 'othername.txt', attachment.filename

267

end

283

end

268

284

269

def test_update_attachments_with_failure

285

def test_update_attachments_with_failure

270

attachments = Attachment.where(:id => [2, 3]).to_a

286

attachments = Attachment.where(:id => [2, 3]).to_a

271

287

272

assert !Attachment.update_attachments(attachments, {

288

assert !Attachment.update_attachments(attachments, {

273

'2' => {:filename => '', :description => 'New description'},

289

'2' => {:filename => '', :description => 'New description'},

274

3 => {:filename => 'othername.txt'}

290

3 => {:filename => 'othername.txt'}

275

})

291

})

276

292

277

attachment = Attachment.find(3)

293

attachment = Attachment.find(3)

278

assert_equal 'logo.gif', attachment.filename

294

assert_equal 'logo.gif', attachment.filename

279

end

295

end

280

296

281

def test_update_attachments_should_sanitize_filename

297

def test_update_attachments_should_sanitize_filename

282

attachments = Attachment.where(:id => 2).to_a

298

attachments = Attachment.where(:id => 2).to_a

283

299

284

assert Attachment.update_attachments(attachments, {

300

assert Attachment.update_attachments(attachments, {

285

2 => {:filename => 'newname?.txt'},

301

2 => {:filename => 'newname?.txt'},

286

})

302

})

287

303

288

attachment = Attachment.find(2)

304

attachment = Attachment.find(2)

289

assert_equal 'newname_.txt', attachment.filename

305

assert_equal 'newname_.txt', attachment.filename

290

end

306

end

291

307

292

def test_latest_attach

308

def test_latest_attach

293

set_fixtures_attachments_directory

309

set_fixtures_attachments_directory

294

a1 = Attachment.find(16)

310

a1 = Attachment.find(16)

295

assert_equal "testfile.png", a1.filename

311

assert_equal "testfile.png", a1.filename

296

assert a1.readable?

312

assert a1.readable?

297

assert (! a1.visible?(User.anonymous))

313

assert (! a1.visible?(User.anonymous))

298

assert a1.visible?(User.find(2))

314

assert a1.visible?(User.find(2))

299

a2 = Attachment.find(17)

315

a2 = Attachment.find(17)

300

assert_equal "testfile.PNG", a2.filename

316

assert_equal "testfile.PNG", a2.filename

301

assert a2.readable?

317

assert a2.readable?

302

assert (! a2.visible?(User.anonymous))

318

assert (! a2.visible?(User.anonymous))

303

assert a2.visible?(User.find(2))

319

assert a2.visible?(User.find(2))

304

assert a1.created_on < a2.created_on

320

assert a1.created_on < a2.created_on

305

321

306

la1 = Attachment.latest_attach([a1, a2], "testfile.png")

322

la1 = Attachment.latest_attach([a1, a2], "testfile.png")

307

assert_equal 17, la1.id

323

assert_equal 17, la1.id

308

la2 = Attachment.latest_attach([a1, a2], "Testfile.PNG")

324

la2 = Attachment.latest_attach([a1, a2], "Testfile.PNG")

309

assert_equal 17, la2.id

325

assert_equal 17, la2.id

310

326

311

set_tmp_attachments_directory

327

set_tmp_attachments_directory

312

end

328

end

313

329

314

def test_thumbnailable_should_be_true_for_images

330

def test_thumbnailable_should_be_true_for_images

315

assert_equal true, Attachment.new(:filename => 'test.jpg').thumbnailable?

331

assert_equal true, Attachment.new(:filename => 'test.jpg').thumbnailable?

316

end

332

end

317

333

318

def test_thumbnailable_should_be_true_for_non_images

334

def test_thumbnailable_should_be_true_for_non_images

319

assert_equal false, Attachment.new(:filename => 'test.txt').thumbnailable?

335

assert_equal false, Attachment.new(:filename => 'test.txt').thumbnailable?

320

end

336

end

321

337

322

if convert_installed?

338

if convert_installed?

323

def test_thumbnail_should_generate_the_thumbnail

339

def test_thumbnail_should_generate_the_thumbnail

324

set_fixtures_attachments_directory

340

set_fixtures_attachments_directory

325

attachment = Attachment.find(16)

341

attachment = Attachment.find(16)

326

Attachment.clear_thumbnails

342

Attachment.clear_thumbnails

327

343

328

assert_difference "Dir.glob(File.join(Attachment.thumbnails_storage_path, '*.thumb')).size" do

344

assert_difference "Dir.glob(File.join(Attachment.thumbnails_storage_path, '*.thumb')).size" do

329

thumbnail = attachment.thumbnail

345

thumbnail = attachment.thumbnail

330

assert_equal "16_8e0294de2441577c529f170b6fb8f638_100.thumb", File.basename(thumbnail)

346

assert_equal "16_8e0294de2441577c529f170b6fb8f638_100.thumb", File.basename(thumbnail)

331

assert File.exists?(thumbnail)

347

assert File.exists?(thumbnail)

332

end

348

end

333

end

349

end

350

351

def test_thumbnail_should_return_nil_if_generation_fails

352

Redmine::Thumbnail.stubs(:generate).raises(SystemCallError, 'Something went wrong')

353

attachment = Attachment.find(16)

354

assert_nil attachment.thumbnail

355

end

334

else

356

else

335

puts '(ImageMagick convert not available)'

357

puts '(ImageMagick convert not available)'

336

end

358

end

337

end

359

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

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2014  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 AttachmentTest < ActiveSupport::TestCase
               fixtures :users, :projects, :roles, :members, :member_roles,
                        :enabled_modules, :issues, :trackers, :attachments
               class MockFile
                 attr_reader :original_filename, :content_type, :content, :size
                 def initialize(attributes)
                   @original_filename = attributes[:original_filename]
                   @content_type = attributes[:content_type]
                   @content = attributes[:content] || "Content"
                   @size = content.size
                 end
               end
               def setup
                 set_tmp_attachments_directory
               end
               def test_container_for_new_attachment_should_be_nil
                 assert_nil Attachment.new.container
               end
               def test_filename_should_remove_eols
                 assert_equal "line_feed", Attachment.new(:filename => "line\nfeed").filename
                 assert_equal "line_feed", Attachment.new(:filename => "some\npath/line\nfeed").filename
                 assert_equal "carriage_return", Attachment.new(:filename => "carriage\rreturn").filename
                 assert_equal "carriage_return", Attachment.new(:filename => "some\rpath/carriage\rreturn").filename
               end
               def test_create
                 a = Attachment.new(:container => Issue.find(1),
                                    :file => uploaded_test_file("testfile.txt", "text/plain"),
                                    :author => User.find(1))
                 assert a.save
                 assert_equal 'testfile.txt', a.filename
                 assert_equal 59, a.filesize
                 assert_equal 'text/plain', a.content_type
                 assert_equal 0, a.downloads
                 assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest
                 assert a.disk_directory
                 assert_match %r{\A\d{4}/\d{2}\z}, a.disk_directory
                 assert File.exist?(a.diskfile)
                 assert_equal 59, File.size(a.diskfile)
               end
+              def test_create_should_clear_content_type_if_too_long
+                a = Attachment.new(:container => Issue.find(1),
+                                   :file => uploaded_test_file("testfile.txt", "text/plain"),
+                                   :author => User.find(1),
+                                   :content_type => 'a'*300)
+                assert a.save
+                a.reload
+                assert_nil a.content_type
+              end
               def test_copy_should_preserve_attributes
                 a = Attachment.find(1)
                 copy = a.copy
                 assert_save copy
                 copy = Attachment.order('id DESC').first
                 %w(filename filesize content_type author_id created_on description digest disk_filename disk_directory diskfile).each do |attribute|
                   assert_equal a.send(attribute), copy.send(attribute), "#{attribute} was different"
                 end
               end
               def test_size_should_be_validated_for_new_file
                 with_settings :attachment_max_size => 0 do
                   a = Attachment.new(:container => Issue.find(1),
                                      :file => uploaded_test_file("testfile.txt", "text/plain"),
                                      :author => User.find(1))
                   assert !a.save
                 end
               end
               def test_size_should_not_be_validated_when_copying
                 a = Attachment.create!(:container => Issue.find(1),
                                        :file => uploaded_test_file("testfile.txt", "text/plain"),
                                        :author => User.find(1))
                 with_settings :attachment_max_size => 0 do
                   copy = a.copy
                   assert copy.save
                 end
               end
               def test_description_length_should_be_validated
                 a = Attachment.new(:description => 'a' * 300)
                 assert !a.save
                 assert_not_equal [], a.errors[:description]
               end
               def test_destroy
                 a = Attachment.new(:container => Issue.find(1),
                                    :file => uploaded_test_file("testfile.txt", "text/plain"),
                                    :author => User.find(1))
                 assert a.save
                 assert_equal 'testfile.txt', a.filename
                 assert_equal 59, a.filesize
                 assert_equal 'text/plain', a.content_type
                 assert_equal 0, a.downloads
                 assert_equal '1478adae0d4eb06d35897518540e25d6', a.digest
                 diskfile = a.diskfile
                 assert File.exist?(diskfile)
                 assert_equal 59, File.size(a.diskfile)
                 assert a.destroy
                 assert !File.exist?(diskfile)
               end
               def test_destroy_should_not_delete_file_referenced_by_other_attachment
                 a = Attachment.create!(:container => Issue.find(1),
                                        :file => uploaded_test_file("testfile.txt", "text/plain"),
                                        :author => User.find(1))
                 diskfile = a.diskfile
                 copy = a.copy
                 copy.save!
                 assert File.exists?(diskfile)
                 a.destroy
                 assert File.exists?(diskfile)
                 copy.destroy
                 assert !File.exists?(diskfile)
               end
               def test_create_should_auto_assign_content_type
                 a = Attachment.new(:container => Issue.find(1),
                                    :file => uploaded_test_file("testfile.txt", ""),
                                    :author => User.find(1))
                 assert a.save
                 assert_equal 'text/plain', a.content_type
               end
               def test_identical_attachments_at_the_same_time_should_not_overwrite
                 a1 = Attachment.create!(:container => Issue.find(1),
                                         :file => uploaded_test_file("testfile.txt", ""),
                                         :author => User.find(1))
                 a2 = Attachment.create!(:container => Issue.find(1),
                                         :file => uploaded_test_file("testfile.txt", ""),
                                         :author => User.find(1))
                 assert a1.disk_filename != a2.disk_filename
               end
               def test_filename_should_be_basenamed
                 a = Attachment.new(:file => MockFile.new(:original_filename => "path/to/the/file"))
                 assert_equal 'file', a.filename
               end
               def test_filename_should_be_sanitized
                 a = Attachment.new(:file => MockFile.new(:original_filename => "valid:[] invalid:?%*|\"'<>chars"))
                 assert_equal 'valid_[] invalid_chars', a.filename
               end
               def test_diskfilename
                 assert Attachment.disk_filename("test_file.txt") =~ /^\d{12}_test_file.txt$/
                 assert_equal 'test_file.txt', Attachment.disk_filename("test_file.txt")[13..-1]
                 assert_equal '770c509475505f37c2b8fb6030434d6b.txt', Attachment.disk_filename("test_accentué.txt")[13..-1]
                 assert_equal 'f8139524ebb8f32e51976982cd20a85d', Attachment.disk_filename("test_accentué")[13..-1]
                 assert_equal 'cbb5b0f30978ba03731d61f9f6d10011', Attachment.disk_filename("test_accentué.ça")[13..-1]
               end
               def test_title
                 a = Attachment.new(:filename => "test.png")
                 assert_equal "test.png", a.title
                 a = Attachment.new(:filename => "test.png", :description => "Cool image")
                 assert_equal "test.png (Cool image)", a.title
               end
+              def test_new_attachment_should_be_editable_by_authot
+                user = User.find(1)
+                a = Attachment.new(:author => user)
+                assert_equal true, a.editable?(user)
+              end
               def test_prune_should_destroy_old_unattached_attachments
                 Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)
                 Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)
                 Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1)
                 assert_difference 'Attachment.count', -2 do
                   Attachment.prune
                 end
               end
               def test_move_from_root_to_target_directory_should_move_root_files
                 a = Attachment.find(20)
                 assert a.disk_directory.blank?
                 # Create a real file for this fixture
                 File.open(a.diskfile, "w") do |f|
                   f.write "test file at the root of files directory"
                 end
                 assert a.readable?
                 Attachment.move_from_root_to_target_directory
                 a.reload
                 assert_equal '2012/05', a.disk_directory
                 assert a.readable?
               end
               test "Attachmnet.attach_files should attach the file" do
                 issue = Issue.first
                 assert_difference 'Attachment.count' do
                   Attachment.attach_files(issue,
                     '1' => {
                       'file' => uploaded_test_file('testfile.txt', 'text/plain'),
                       'description' => 'test'
                     })
                 end
                 attachment = Attachment.order('id DESC').first
                 assert_equal issue, attachment.container
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 59, attachment.filesize
                 assert_equal 'test', attachment.description
                 assert_equal 'text/plain', attachment.content_type
                 assert File.exists?(attachment.diskfile)
                 assert_equal 59, File.size(attachment.diskfile)
               end
               test "Attachmnet.attach_files should add unsaved files to the object as unsaved attachments" do
                 # Max size of 0 to force Attachment creation failures
                 with_settings(:attachment_max_size => 0) do
                   @project = Project.find(1)
                   response = Attachment.attach_files(@project, {
                                                        '1' => {'file' => mock_file, 'description' => 'test'},
                                                        '2' => {'file' => mock_file, 'description' => 'test'}
                                                      })
                   assert response[:unsaved].present?
                   assert_equal 2, response[:unsaved].length
                   assert response[:unsaved].first.new_record?
                   assert response[:unsaved].second.new_record?
                   assert_equal response[:unsaved], @project.unsaved_attachments
                 end
               end
               test "Attachment.attach_files should preserve the content_type of attachments added by token" do
                 @project = Project.find(1)
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", ""), :author_id => 1, :created_on => 2.days.ago)
                 assert_equal 'text/plain', attachment.content_type
                 Attachment.attach_files(@project, { '1' => {'token' => attachment.token } })
                 attachment.reload
                 assert_equal 'text/plain', attachment.content_type
               end
               def test_update_attachments
                 attachments = Attachment.where(:id => [2, 3]).to_a
                 assert Attachment.update_attachments(attachments, {
                   '2' => {:filename => 'newname.txt', :description => 'New description'},
 => {:filename => 'othername.txt'}
                 })
                 attachment = Attachment.find(2)
                 assert_equal 'newname.txt', attachment.filename
                 assert_equal 'New description', attachment.description
                 attachment = Attachment.find(3)
                 assert_equal 'othername.txt', attachment.filename
               end
               def test_update_attachments_with_failure
                 attachments = Attachment.where(:id => [2, 3]).to_a
                 assert !Attachment.update_attachments(attachments, {
                   '2' => {:filename => '', :description => 'New description'},
 => {:filename => 'othername.txt'}
                 })
                 attachment = Attachment.find(3)
                 assert_equal 'logo.gif', attachment.filename
               end
               def test_update_attachments_should_sanitize_filename
                 attachments = Attachment.where(:id => 2).to_a
                 assert Attachment.update_attachments(attachments, {
 => {:filename => 'newname?.txt'},
                 })
                 attachment = Attachment.find(2)
                 assert_equal 'newname_.txt', attachment.filename
               end
               def test_latest_attach
                 set_fixtures_attachments_directory
                 a1 = Attachment.find(16)
                 assert_equal "testfile.png", a1.filename
                 assert a1.readable?
                 assert (! a1.visible?(User.anonymous))
                 assert a1.visible?(User.find(2))
                 a2 = Attachment.find(17)
                 assert_equal "testfile.PNG", a2.filename
                 assert a2.readable?
                 assert (! a2.visible?(User.anonymous))
                 assert a2.visible?(User.find(2))
                 assert a1.created_on < a2.created_on
                 la1 = Attachment.latest_attach([a1, a2], "testfile.png")
                 assert_equal 17, la1.id
                 la2 = Attachment.latest_attach([a1, a2], "Testfile.PNG")
                 assert_equal 17, la2.id
                 set_tmp_attachments_directory
               end
               def test_thumbnailable_should_be_true_for_images
                 assert_equal true, Attachment.new(:filename => 'test.jpg').thumbnailable?
               end
               def test_thumbnailable_should_be_true_for_non_images
                 assert_equal false, Attachment.new(:filename => 'test.txt').thumbnailable?
               end
               if convert_installed?
                 def test_thumbnail_should_generate_the_thumbnail
                   set_fixtures_attachments_directory
                   attachment = Attachment.find(16)
                   Attachment.clear_thumbnails
                   assert_difference "Dir.glob(File.join(Attachment.thumbnails_storage_path, '*.thumb')).size" do
                     thumbnail = attachment.thumbnail
                     assert_equal "16_8e0294de2441577c529f170b6fb8f638_100.thumb", File.basename(thumbnail)
                     assert File.exists?(thumbnail)
                   end
                 end
+                def test_thumbnail_should_return_nil_if_generation_fails
+                  Redmine::Thumbnail.stubs(:generate).raises(SystemCallError, 'Something went wrong')
+                  attachment = Attachment.find(16)
+                  assert_nil attachment.thumbnail
+                end
               else
                 puts '(ImageMagick convert not available)'
               end
             end