~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

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

• reverse the comparison (5622.2.9 to 6170)
• stop comparing with revision 6170

Show diffs side-by-side

added

removed

bzrlib/tests/test_workingtree.py

15

15

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

16

16

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

17

17

 

 

18

import os

 

19

 

18

20

from bzrlib import (

19

21

    bzrdir,

20

22

    conflicts,

21

23

    errors,

22

 

    symbol_versioning,

23

24

    transport,

24

25

    workingtree,

25

 

    workingtree_3,

26

 

    workingtree_4,

27

26

    )

28

27

from bzrlib.lockdir import LockDir

29

28

from bzrlib.mutabletree import needs_tree_write_lock

63

62

class TestDefaultFormat(TestCaseWithTransport):

64

63

 

65

64

    def test_get_set_default_format(self):

66

 

        old_format = workingtree.format_registry.get_default()

67

 

        # default is 6

68

 

        self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))

69

 

        workingtree.format_registry.set_default(SampleTreeFormat())

70

 

        try:

71

 

            # the default branch format is used by the meta dir format

72

 

            # which is not the default bzrdir format at this point

73

 

            dir = bzrdir.BzrDirMetaFormat1().initialize('.')

74

 

            dir.create_repository()

75

 

            dir.create_branch()

76

 

            result = dir.create_workingtree()

77

 

            self.assertEqual(result, 'A tree')

78

 

        finally:

79

 

            workingtree.format_registry.set_default(old_format)

80

 

        self.assertEqual(old_format, workingtree.format_registry.get_default())

81

 

 

82

 

    def test_get_set_default_format_by_key(self):

83

 

        old_format = workingtree.format_registry.get_default()

84

 

        # default is 6

85

 

        format = SampleTreeFormat()

86

 

        workingtree.format_registry.register(format)

87

 

        self.addCleanup(workingtree.format_registry.remove, format)

88

 

        self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))

89

 

        workingtree.format_registry.set_default_key(format.get_format_string())

90

 

        try:

91

 

            # the default branch format is used by the meta dir format

92

 

            # which is not the default bzrdir format at this point

93

 

            dir = bzrdir.BzrDirMetaFormat1().initialize('.')

94

 

            dir.create_repository()

95

 

            dir.create_branch()

96

 

            result = dir.create_workingtree()

97

 

            self.assertEqual(result, 'A tree')

98

 

        finally:

99

 

            workingtree.format_registry.set_default_key(

100

 

                old_format.get_format_string())

101

 

        self.assertEqual(old_format, workingtree.format_registry.get_default())

 

65

        old_format = workingtree.WorkingTreeFormat.get_default_format()

 

66

        # default is 3

 

67

        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))

 

68

        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())

 

69

        try:

 

70

            # the default branch format is used by the meta dir format

 

71

            # which is not the default bzrdir format at this point

 

72

            dir = bzrdir.BzrDirMetaFormat1().initialize('.')

 

73

            dir.create_repository()

 

74

            dir.create_branch()

 

75

            result = dir.create_workingtree()

 

76

            self.assertEqual(result, 'A tree')

 

77

        finally:

 

78

            workingtree.WorkingTreeFormat.set_default_format(old_format)

 

79

        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())

102

80

 

103

81

    def test_open(self):

104

82

        tree = self.make_branch_and_tree('.')

168

146

class TestWorkingTreeFormat(TestCaseWithTransport):

169

147

    """Tests for the WorkingTreeFormat facility."""

170

148

 

171

 

    def test_find_format_string(self):

172

 

        # is the right format object found for a working tree?

173

 

        branch = self.make_branch('branch')

174

 

        self.assertRaises(errors.NoWorkingTree,

175

 

            workingtree.WorkingTreeFormat.find_format_string, branch.bzrdir)

176

 

        transport = branch.bzrdir.get_workingtree_transport(None)

177

 

        transport.mkdir('.')

178

 

        transport.put_bytes("format", "some format name")

179

 

        # The format does not have to be known by Bazaar,

180

 

        # find_format_string just retrieves the name

181

 

        self.assertEquals("some format name",

182

 

            workingtree.WorkingTreeFormat.find_format_string(branch.bzrdir))

183

 

 

184

149

    def test_find_format(self):

185

150

        # is the right format object found for a working tree?

186

151

        # create a branch with a few known format objects.

192

157

            format.initialize(dir)

193

158

            t = transport.get_transport(url)

194

159

            found_format = workingtree.WorkingTreeFormat.find_format(dir)

195

 

            self.assertIsInstance(found_format, format.__class__)

196

 

        check_format(workingtree_3.WorkingTreeFormat3(), "bar")

 

160

            self.failUnless(isinstance(found_format, format.__class__))

 

161

        check_format(workingtree.WorkingTreeFormat3(), "bar")

197

162

 

198

163

    def test_find_format_no_tree(self):

199

164

        dir = bzrdir.BzrDirMetaFormat1().initialize('.')

219

184

        # make a branch

220

185

        format.initialize(dir)

221

186

        # register a format for it.

222

 

        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

223

 

            workingtree.WorkingTreeFormat.register_format, format)

224

 

        self.assertTrue(format in 

225

 

            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

226

 

                workingtree.WorkingTreeFormat.get_formats))

 

187

        workingtree.WorkingTreeFormat.register_format(format)

 

188

        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())

227

189

        # which branch.Open will refuse (not supported)

228

190

        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')

229

191

        # but open_downlevel will work

230

192

        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))

231

193

        # unregister the format

232

 

        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

233

 

            workingtree.WorkingTreeFormat.unregister_format, format)

234

 

        self.assertFalse(format in

235

 

            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

236

 

                workingtree.WorkingTreeFormat.get_formats))

237

 

 

238

 

 

239

 

class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):

240

 

 

241

 

    def make_simple_tree(self):

242

 

        tree = self.make_branch_and_tree('tree', format='development-subtree')

243

 

        self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])

244

 

        tree.set_root_id('root-id')

245

 

        tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])

246

 

        tree.commit('initial')

247

 

        return tree

248

 

 

249

 

    def test_just_directory(self):

250

 

        tree = self.make_simple_tree()

251

 

        self.assertEqual([('directory', 'root-id'),

252

 

                          ('directory', 'a-id'),

253

 

                          ('directory', 'b-id'),

254

 

                          ('file', 'c-id')],

255

 

                         [(ie.kind, ie.file_id)

256

 

                          for path, ie in tree.iter_entries_by_dir()])

257

 

        subtree = self.make_branch_and_tree('tree/a/b')

258

 

        self.assertEqual([('tree-reference', 'b-id')],

259

 

                         [(ie.kind, ie.file_id)

260

 

                          for path, ie in tree.iter_entries_by_dir(['b-id'])])

261

 

 

262

 

    def test_direct_subtree(self):

263

 

        tree = self.make_simple_tree()

264

 

        subtree = self.make_branch_and_tree('tree/a/b')

265

 

        self.assertEqual([('directory', 'root-id'),

266

 

                          ('directory', 'a-id'),

267

 

                          ('tree-reference', 'b-id')],

268

 

                         [(ie.kind, ie.file_id)

269

 

                          for path, ie in tree.iter_entries_by_dir()])

270

 

 

271

 

    def test_indirect_subtree(self):

272

 

        tree = self.make_simple_tree()

273

 

        subtree = self.make_branch_and_tree('tree/a')

274

 

        self.assertEqual([('directory', 'root-id'),

275

 

                          ('tree-reference', 'a-id')],

276

 

                         [(ie.kind, ie.file_id)

277

 

                          for path, ie in tree.iter_entries_by_dir()])

278

 

 

279

 

 

280

 

class TestWorkingTreeFormatRegistry(TestCase):

281

 

 

282

 

    def setUp(self):

283

 

        super(TestWorkingTreeFormatRegistry, self).setUp()

284

 

        self.registry = workingtree.WorkingTreeFormatRegistry()

285

 

 

286

 

    def test_register_unregister_format(self):

287

 

        format = SampleTreeFormat()

288

 

        self.registry.register(format)

289

 

        self.assertEquals(format, self.registry.get("Sample tree format."))

290

 

        self.registry.remove(format)

291

 

        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")

292

 

 

293

 

    def test_get_all(self):

294

 

        format = SampleTreeFormat()

295

 

        self.assertEquals([], self.registry._get_all())

296

 

        self.registry.register(format)

297

 

        self.assertEquals([format], self.registry._get_all())

298

 

 

299

 

    def test_register_extra(self):

 

194

        workingtree.WorkingTreeFormat.unregister_format(format)

 

195

        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())

 

196

 

 

197

    def test_register_unregister_extra_format(self):

300

198

        format = SampleExtraTreeFormat()

301

 

        self.assertEquals([], self.registry._get_all())

302

 

        self.registry.register_extra(format)

303

 

        self.assertEquals([format], self.registry._get_all())

304

 

 

305

 

    def test_register_extra_lazy(self):

306

 

        self.assertEquals([], self.registry._get_all())

307

 

        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",

308

 

            "SampleExtraTreeFormat")

309

 

        formats = self.registry._get_all()

310

 

        self.assertEquals(1, len(formats))

311

 

        self.assertIsInstance(formats[0], SampleExtraTreeFormat)

 

199

        workingtree.WorkingTreeFormat.register_extra_format(format)

 

200

        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())

 

201

        workingtree.WorkingTreeFormat.unregister_extra_format(format)

 

202

        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())

312

203

 

313

204

 

314

205

class TestWorkingTreeFormat3(TestCaseWithTransport):

318

209

        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())

319

210

        control.create_repository()

320

211

        control.create_branch()

321

 

        tree = workingtree_3.WorkingTreeFormat3().initialize(control)

 

212

        tree = workingtree.WorkingTreeFormat3().initialize(control)

322

213

        # we want:

323

214

        # format 'Bazaar-NG Working Tree format 3'

324

215

        # inventory = blank inventory

352

243

        repo = dir.create_repository()

353

244

        branch = dir.create_branch()

354

245

        try:

355

 

            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)

 

246

            tree = workingtree.WorkingTreeFormat3().initialize(dir)

356

247

        except errors.NotLocalUrl:

357

248

            raise TestSkipped('Not a local URL')

358

249

        self.assertIsDirectory('.bzr', t)

369

260

        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())

370

261

        control.create_repository()

371

262

        control.create_branch()

372

 

        tree = workingtree_3.WorkingTreeFormat3().initialize(control)

 

263

        tree = workingtree.WorkingTreeFormat3().initialize(control)

373

264

        tree._transport.delete("pending-merges")

374

265

        self.assertEqual([], tree.get_parent_ids())

375

266

 

376

267

 

 

268

class TestFormat2WorkingTree(TestCaseWithTransport):

 

269

    """Tests that are specific to format 2 trees."""

 

270

 

 

271

    def create_format2_tree(self, url):

 

272

        return self.make_branch_and_tree(

 

273

            url, format=bzrdir.BzrDirFormat6())

 

274

 

 

275

    def test_conflicts(self):

 

276

        # test backwards compatability

 

277

        tree = self.create_format2_tree('.')

 

278

        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,

 

279

                          None)

 

280

        file('lala.BASE', 'wb').write('labase')

 

281

        expected = conflicts.ContentsConflict('lala')

 

282

        self.assertEqual(list(tree.conflicts()), [expected])

 

283

        file('lala', 'wb').write('la')

 

284

        tree.add('lala', 'lala-id')

 

285

        expected = conflicts.ContentsConflict('lala', file_id='lala-id')

 

286

        self.assertEqual(list(tree.conflicts()), [expected])

 

287

        file('lala.THIS', 'wb').write('lathis')

 

288

        file('lala.OTHER', 'wb').write('laother')

 

289

        # When "text conflict"s happen, stem, THIS and OTHER are text

 

290

        expected = conflicts.TextConflict('lala', file_id='lala-id')

 

291

        self.assertEqual(list(tree.conflicts()), [expected])

 

292

        os.unlink('lala.OTHER')

 

293

        os.mkdir('lala.OTHER')

 

294

        expected = conflicts.ContentsConflict('lala', file_id='lala-id')

 

295

        self.assertEqual(list(tree.conflicts()), [expected])

 

296

 

 

297

 

377

298

class InstrumentedTree(object):

378

299

    """A instrumented tree to check the needs_tree_write_lock decorator."""

379

300

 

450

371

        self.build_tree_contents([('other/hello', 'hELLO')])

451

372

        other.commit('Case switch')

452

373

        this = base.bzrdir.sprout('this').open_workingtree()

453

 

        self.assertPathExists('this/hello')

 

374

        self.failUnlessExists('this/hello')

454

375

        self.build_tree_contents([('this/hello', 'Hello World')])

455

376

        this.commit('Add World')

456

377

        this.merge_from_branch(other.branch)

477

398

        self.assertEqual([], this.conflicts())

478

399

        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],

479

400

                         resolved)

480

 

        self.assertPathDoesNotExist('this/hello.BASE')

 

401

        self.failIfExists('this/hello.BASE')

481

402

 

482

403

    def test_auto_resolve_dir(self):

483

404

        tree = self.make_branch_and_tree('tree')

• Older »

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