~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_workingtree/test_remove.py

• browse files at revision 5127.1.5
• compare with another revision
• download diff
• download tarball
• view history from revision 5127.1.5

• reverse the comparison (5127.1.5 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

bzrlib/tests/per_workingtree/test_remove.py

1

 

# Copyright (C) 2007-2010 Canonical Ltd

 

1

# Copyright (C) 2006, 2007, 2008 Canonical Ltd

2

2

#

3

3

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

4

4

# it under the terms of the GNU General Public License as published by

24

24

 

25

25

    files = ['a', 'b/', 'b/c', 'd/']

26

26

    rfiles = ['b/c', 'b', 'a', 'd']

27

 

    backup_files = ['a.~1~', 'b.~1~/', 'b.~1~/c.~1~', 'd.~1~/']

28

27

 

29

28

    def get_tree(self, files):

30

29

        tree = self.make_branch_and_tree('.')

73

72

        tree._validate()

74

73

 

75

74

    def test_remove_added_files(self):

76

 

        """Removal of newly added files must back them up."""

 

75

        """Removal of newly added files must fail."""

77

76

        tree = self.get_tree(TestRemove.files)

78

77

        tree.add(TestRemove.files)

79

78

        self.assertInWorkingTree(TestRemove.files)

80

 

        tree.remove(TestRemove.files, keep_files=False)

81

 

        self.assertNotInWorkingTree(TestRemove.files)

82

 

        self.failUnlessExists(TestRemove.backup_files)

 

79

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

80

            TestRemove.files, keep_files=False)

 

81

        self.assertContainsRe(err.changes_as_text,

 

82

            '(?s)added:.*a.*b/.*b/c.*d/')

 

83

        self.assertInWorkingTree(TestRemove.files)

 

84

        self.failUnlessExists(TestRemove.files)

83

85

        tree._validate()

84

86

 

85

87

    def test_remove_changed_file(self):

86

 

        """Removal of changed files must back it up."""

 

88

        """Removal of a changed files must fail."""

87

89

        tree = self.get_committed_tree(['a'])

88

90

        self.build_tree_contents([('a', "some other new content!")])

89

91

        self.assertInWorkingTree('a')

90

 

        tree.remove('a', keep_files=False)

91

 

        self.assertNotInWorkingTree(TestRemove.files)

92

 

        self.failUnlessExists('a.~1~')

 

92

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

93

            'a', keep_files=False)

 

94

        self.assertContainsRe(err.changes_as_text, '(?s)modified:.*a')

 

95

        self.assertInWorkingTree('a')

 

96

        self.failUnlessExists('a')

93

97

        tree._validate()

94

98

 

95

99

    def test_remove_deleted_files(self):

118

122

        tree._validate()

119

123

 

120

124

    def test_remove_renamed_changed_files(self):

121

 

        """Check that files that are renamed and changed are backed up."""

 

125

        """Check that files are not removed if they are renamed and changed."""

122

126

        tree = self.get_committed_tree(TestRemove.files)

123

127

 

124

128

        for f in TestRemove.rfiles:

129

133

        self.assertInWorkingTree(rfilesx)

130

134

        self.failUnlessExists(rfilesx)

131

135

 

132

 

        tree.remove(rfilesx, keep_files=False)

133

 

        self.assertNotInWorkingTree(rfilesx)

134

 

        self.failUnlessExists(['bx.~1~/cx.~1~', 'bx.~1~', 'ax.~1~'])

135

 

        self.failIfExists('dx.~1~') # unchanged file

 

136

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

137

            rfilesx, keep_files=False)

 

138

        self.assertContainsRe(err.changes_as_text,

 

139

            '(?s)modified:.*ax.*bx/cx')

 

140

        self.assertInWorkingTree(rfilesx)

 

141

        self.failUnlessExists(rfilesx)

136

142

        tree._validate()

137

143

 

138

144

    def test_force_remove_changed_files(self):

143

149

 

144

150

        tree.remove(TestRemove.files, keep_files=False, force=True)

145

151

        self.assertRemovedAndDeleted(TestRemove.files)

146

 

        self.failIfExists(['a.~1~', 'b.~1~/', 'b.~1~/c', 'd.~1~/'])

147

152

        tree._validate()

148

153

 

149

154

    def test_remove_unknown_files(self):

150

 

        """Unknown files shuld be backed up"""

 

155

        """Try to delete unknown files."""

151

156

        tree = self.get_tree(TestRemove.files)

152

 

        tree.remove(TestRemove.files, keep_files=False)

153

 

        self.assertRemovedAndDeleted(TestRemove.files)

154

 

        self.failUnlessExists(TestRemove.backup_files)

 

157

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

158

            TestRemove.files, keep_files=False)

 

159

        self.assertContainsRe(err.changes_as_text,

 

160

            '(?s)unknown:.*d/.*b/c.*b/.*a.*')

155

161

        tree._validate()

156

162

 

157

163

    def test_remove_nonexisting_files(self):

196

202

        tree._validate()

197

203

 

198

204

    def test_remove_changed_ignored_files(self):

199

 

        """Changed ignored files should be backed up."""

 

205

        """Changed ignored files should not be deleted."""

200

206

        files = ['an_ignored_file']

201

207

        tree = self.get_tree(files)

202

208

        tree.add(files)

203

209

        ignores.add_runtime_ignores(["*ignored*"])

204

210

        self.assertInWorkingTree(files)

205

211

        self.assertNotEquals(None, tree.is_ignored(files[0]))

206

 

 

207

 

        tree.remove(files, keep_files=False)

208

 

        self.assertNotInWorkingTree(files)

209

 

        self.failUnlessExists('an_ignored_file.~1~')

 

212

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

213

            files, keep_files=False)

 

214

        self.assertContainsRe(err.changes_as_text,

 

215

            '(?s)added:.*' + files[0])

 

216

        self.assertInWorkingTree(files)

210

217

        tree._validate()

211

218

 

212

219

    def test_dont_remove_directory_with_unknowns(self):

213

 

        """Directories with unknowns should be backed up."""

 

220

        """Directories with unknowns should not be deleted."""

214

221

        directories = ['a/', 'b/', 'c/', 'c/c/']

215

222

        tree = self.get_committed_tree(directories)

216

223

 

217

224

        self.build_tree(['a/unknown_file'])

218

 

        tree.remove('a', keep_files=False)

219

 

        self.failUnlessExists('a.~1~/unknown_file')

 

225

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

226

            'a', keep_files=False)

 

227

        self.assertContainsRe(err.changes_as_text,

 

228

            '(?s)unknown:.*a/unknown_file')

220

229

 

221

230

        self.build_tree(['b/unknown_directory'])

222

 

        tree.remove('b', keep_files=False)

223

 

        self.failUnlessExists('b.~1~/unknown_directory')

 

231

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

232

            'b', keep_files=False)

 

233

        self.assertContainsRe(err.changes_as_text,

 

234

            '(?s)unknown:.*b/unknown_directory')

224

235

 

225

236

        self.build_tree(['c/c/unknown_file'])

226

 

        tree.remove('c/c', keep_files=False)

227

 

        self.failUnlessExists('c/c.~1~/unknown_file')

228

 

 

229

 

        tree.remove('c', keep_files=False)

230

 

        self.failUnlessExists('c.~1~/')

231

 

 

232

 

        self.assertNotInWorkingTree(directories)

 

237

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

238

            'c/c', keep_files=False)

 

239

        self.assertContainsRe(err.changes_as_text,

 

240

            '(?s)unknown:.*c/c/unknown_file')

 

241

 

 

242

        self.assertInWorkingTree(directories)

 

243

        self.failUnlessExists(directories)

233

244

        tree._validate()

234

245

 

235

246

    def test_force_remove_directory_with_unknowns(self):

251

262

        tree._validate()

252

263

 

253

264

    def test_remove_directory_with_changed_file(self):

254

 

        """Backup directories with changed files."""

255

 

        files = ['b/', 'b/c']

256

 

        tree = self.get_committed_tree(files)

257

 

        self.build_tree_contents([('b/c', "some other new content!")])

258

 

 

259

 

        tree.remove('b', keep_files=False)

260

 

        self.failUnlessExists('b.~1~/c.~1~')

261

 

        self.assertNotInWorkingTree(files)

262

 

 

263

 

    def test_remove_force_directory_with_changed_file(self):

264

 

        """Delete directories with changed files when forced."""

265

 

        files = ['b/', 'b/c']

266

 

        tree = self.get_committed_tree(files)

267

 

        self.build_tree_contents([('b/c', "some other new content!")])

 

265

        """Refuse to delete directories with changed files."""

 

266

        files = ['b/', 'b/c']

 

267

        tree = self.get_committed_tree(files)

 

268

        self.build_tree_contents([('b/c', "some other new content!")])

 

269

 

 

270

        err = self.assertRaises(errors.BzrRemoveChangedFilesError, tree.remove,

 

271

            'b', keep_files=False)

 

272

        self.assertContainsRe(err.changes_as_text, '(?s)modified:.*b/c')

 

273

        self.assertInWorkingTree(files)

 

274

        self.failUnlessExists(files)

268

275

 

269

276

        # see if we can force it now..

270

277

        tree.remove('b', keep_files=False, force=True)

271

278

        self.assertRemovedAndDeleted(files)

272

279

        tree._validate()

273

280

 

274

 

    def test_remove_directory_with_changed_emigrated_file(self):

275

 

        # As per bug #129880

276

 

        tree = self.make_branch_and_tree('.')

277

 

        self.build_tree_contents([('somedir/',), ('somedir/file', 'contents')])

278

 

        tree.add(['somedir', 'somedir/file'])

279

 

        tree.commit(message="first")

280

 

        self.build_tree_contents([('somedir/file', 'changed')])

281

 

        tree.rename_one('somedir/file', 'moved-file')

282

 

        tree.remove('somedir', keep_files=False)

283

 

        self.assertNotInWorkingTree('somedir')

284

 

        self.failIfExists('somedir')

285

 

        self.assertInWorkingTree('moved-file')

286

 

        self.failUnlessExists('moved-file')

287

 

 

288

281

    def test_remove_directory_with_renames(self):

289

282

        """Delete directory with renames in or out."""

290

283

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1