/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_workingtree.py

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

• reverse the comparison (6973.12.6 to 7490.22.1)
• stop comparing with revision 7490.22.1

Show diffs side-by-side

added

removed

breezy/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

 

from io import BytesIO

19

 

import os

20

 

 

21

18

from .. import (

22

19

    conflicts,

23

20

    errors,

24

 

    symbol_versioning,

25

 

    trace,

 

21

    lock,

26

22

    transport,

27

23

    workingtree,

28

24

    )

42

38

    TreeLink,

43

39

    )

44

40

 

45

 

from .features import SymlinkFeature

46

41

 

47

42

class TestTreeDirectory(TestCaseWithTransport):

48

43

 

73

68

    def test_get_set_default_format(self):

74

69

        old_format = workingtree.format_registry.get_default()

75

70

        # default is 6

76

 

        self.assertTrue(isinstance(

77

 

            old_format, workingtree_4.WorkingTreeFormat6))

 

71

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

78

72

        workingtree.format_registry.set_default(SampleTreeFormat())

79

73

        try:

80

74

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

92

86

        self.assertIsInstance(

93

87

            SampleTreeFormat.from_string(b"Sample tree format."),

94

88

            SampleTreeFormat)

95

 

        self.assertRaises(

96

 

            AssertionError, SampleTreeFormat.from_string,

97

 

            b"Different format string.")

 

89

        self.assertRaises(AssertionError,

 

90

            SampleTreeFormat.from_string, b"Different format string.")

98

91

 

99

92

    def test_get_set_default_format_by_key(self):

100

93

        old_format = workingtree.format_registry.get_default()

102

95

        format = SampleTreeFormat()

103

96

        workingtree.format_registry.register(format)

104

97

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

105

 

        self.assertTrue(isinstance(

106

 

            old_format, workingtree_4.WorkingTreeFormat6))

 

98

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

107

99

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

108

100

        try:

109

101

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

133

125

        open_no_args, relpath = workingtree.WorkingTree.open_containing()

134

126

        self.assertEqual(tree.basedir, open_no_args.basedir)

135

127

        self.assertEqual('', relpath)

136

 

        open_subdir, relpath = workingtree.WorkingTree.open_containing(

137

 

            'subdir')

 

128

        open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')

138

129

        self.assertEqual(tree.basedir, open_subdir.basedir)

139

130

        self.assertEqual('subdir', relpath)

140

131

 

191

182

    def test_find_format_string(self):

192

183

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

193

184

        branch = self.make_branch('branch')

194

 

        self.assertRaises(

195

 

            errors.NoWorkingTree,

196

 

            bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string,

197

 

            branch.controldir)

 

185

        self.assertRaises(errors.NoWorkingTree,

 

186

            bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string, branch.controldir)

198

187

        transport = branch.controldir.get_workingtree_transport(None)

199

188

        transport.mkdir('.')

200

 

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

 

189

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

201

190

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

202

191

        # find_format_string just retrieves the name

203

 

        self.assertEqual(

204

 

            b"some format name",

205

 

            bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string(

206

 

                branch.controldir))

 

192

        self.assertEqual("some format name",

 

193

            bzrworkingtree.WorkingTreeFormatMetaDir.find_format_string(branch.controldir))

207

194

 

208

195

    def test_find_format(self):

209

196

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

210

197

        # create a branch with a few known format objects.

211

198

        self.build_tree(["foo/", "bar/"])

212

 

 

213

199

        def check_format(format, url):

214

200

            dir = format._matchingcontroldir.initialize(url)

215

201

            dir.create_repository()

216

202

            dir.create_branch()

217

203

            format.initialize(dir)

218

 

            found_format = bzrworkingtree.WorkingTreeFormatMetaDir.find_format(

219

 

                dir)

 

204

            t = transport.get_transport(url)

 

205

            found_format = bzrworkingtree.WorkingTreeFormatMetaDir.find_format(dir)

220

206

            self.assertIsInstance(found_format, format.__class__)

221

207

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

222

208

 

242

228

            tree.controldir)

243

229

        self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)

244

230

        self.assertEqual(found_format.features.get(b"name"), b"necessity")

245

 

        self.assertRaises(

246

 

            bzrdir.MissingFeature, found_format.check_support_status, True)

247

 

        self.addCleanup(

248

 

            bzrworkingtree.WorkingTreeFormatMetaDir.unregister_feature,

 

231

        self.assertRaises(bzrdir.MissingFeature, found_format.check_support_status,

 

232

            True)

 

233

        self.addCleanup(bzrworkingtree.WorkingTreeFormatMetaDir.unregister_feature,

249

234

            b"name")

250

235

        bzrworkingtree.WorkingTreeFormatMetaDir.register_feature(b"name")

251

236

        found_format.check_support_status(True)

269

254

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

270

255

                         [(ie.kind, ie.file_id)

271

256

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

272

 

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

 

257

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

273

258

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

274

259

                         [(ie.kind, ie.file_id)

275

260

                          for path, ie in tree.iter_entries_by_dir(

277

262

 

278

263

    def test_direct_subtree(self):

279

264

        tree = self.make_simple_tree()

280

 

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

 

265

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

281

266

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

282

267

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

283

268

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

286

271

 

287

272

    def test_indirect_subtree(self):

288

273

        tree = self.make_simple_tree()

289

 

        self.make_branch_and_tree('tree/a')

 

274

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

290

275

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

291

276

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

292

277

                         [(ie.kind, ie.file_id)

321

306

    def test_register_extra_lazy(self):

322

307

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

323

308

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

324

 

                                          "SampleExtraTreeFormat")

 

309

            "SampleExtraTreeFormat")

325

310

        formats = self.registry._get_all()

326

311

        self.assertEqual(1, len(formats))

327

312

        self.assertIsInstance(formats[0], SampleExtraTreeFormat)

334

319

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

335

320

        control.create_repository()

336

321

        control.create_branch()

337

 

        workingtree_3.WorkingTreeFormat3().initialize(control)

 

322

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

338

323

        # we want:

339

324

        # format 'Bazaar-NG Working Tree format 3'

340

325

        # inventory = blank inventory

345

330

        self.assertEqualDiff(b'Bazaar-NG Working Tree format 3',

346

331

                             t.get('format').read())

347

332

        self.assertEqualDiff(t.get('inventory').read(),

348

 

                             b'<inventory format="5">\n'

349

 

                             b'</inventory>\n',

 

333

                              b'<inventory format="5">\n'

 

334

                              b'</inventory>\n',

350

335

                             )

351

336

        self.assertEqualDiff(b'### bzr hashcache v5\n',

352

337

                             t.get('stat-cache').read())

365

350

        t = self.get_transport()

366

351

        url = self.get_url()

367

352

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

368

 

        dir.create_repository()

369

 

        dir.create_branch()

 

353

        repo = dir.create_repository()

 

354

        branch = dir.create_branch()

370

355

        try:

371

356

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

372

357

        except errors.NotLocalUrl:

397

382

                                  ('this-tree/foo/bar', b'bar')])

398

383

        this_tree.add(['foo', 'foo/bar'])

399

384

        this_tree.commit('created foo/bar')

400

 

        other_tree = this_tree.controldir.sprout(

401

 

            'other-tree').open_workingtree()

 

385

        other_tree = this_tree.controldir.sprout('other-tree').open_workingtree()

402

386

        self.build_tree_contents([('other-tree/foo/bar', b'baz')])

403

387

        other_tree.commit('changed bar')

404

388

        self.build_tree_contents([('this-tree/foo/bar', b'qux')])

411

395

 

412

396

class TestAutoResolve(TestCaseWithTransport):

413

397

 

414

 

    def _auto_resolve(self, tree):

415

 

        """Call auto_resolve on tree expecting deprecation"""

416

 

        return self.applyDeprecated(

417

 

            symbol_versioning.deprecated_in((3, 0, 1)),

418

 

            tree.auto_resolve,)

419

 

 

420

398

    def test_auto_resolve(self):

421

399

        base = self.make_branch_and_tree('base')

422

400

        self.build_tree_contents([('base/hello', b'Hello')])

432

410

        this.merge_from_branch(other.branch)

433

411

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

434

412

                         this.conflicts())

435

 

        self._auto_resolve(this)

436

 

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

437

 

                         this.conflicts())

438

 

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

439

 

        self._auto_resolve(this)

440

 

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

441

 

                         this.conflicts())

442

 

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

443

 

        self._auto_resolve(this)

444

 

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

445

 

                         this.conflicts())

446

 

        self.build_tree_contents([('this/hello', '\n>>>>>>>')])

447

 

        remaining, resolved = self._auto_resolve(this)

 

413

        this.auto_resolve()

 

414

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

 

415

                         this.conflicts())

 

416

        self.build_tree_contents([('this/hello', b'<<<<<<<')])

 

417

        this.auto_resolve()

 

418

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

 

419

                         this.conflicts())

 

420

        self.build_tree_contents([('this/hello', b'=======')])

 

421

        this.auto_resolve()

 

422

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

 

423

                         this.conflicts())

 

424

        self.build_tree_contents([('this/hello', b'\n>>>>>>>')])

 

425

        remaining, resolved = this.auto_resolve()

448

426

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

449

427

                         this.conflicts())

450

428

        self.assertEqual([], resolved)

451

429

        self.build_tree_contents([('this/hello', b'hELLO wORLD')])

452

 

        remaining, resolved = self._auto_resolve(this)

 

430

        remaining, resolved = this.auto_resolve()

453

431

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

454

432

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

455

433

                         resolved)

456

434

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

457

435

 

458

 

    def test_unsupported_symlink_auto_resolve(self):

459

 

        self.requireFeature(SymlinkFeature)

460

 

        base = self.make_branch_and_tree('base')

461

 

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

462

 

        base.add('hello', b'hello_id')

463

 

        base.commit('commit 0')

464

 

        other = base.controldir.sprout('other').open_workingtree()

465

 

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

466

 

        os.symlink('other/hello', 'other/foo')

467

 

        other.add('foo', b'foo_id')

468

 

        other.commit('commit symlink')

469

 

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

470

 

        self.assertPathExists('this/hello')

471

 

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

472

 

        this.commit('commit 2')

473

 

        log = BytesIO()

474

 

        trace.push_log_file(log)

475

 

        os_symlink = getattr(os, 'symlink', None)

476

 

        os.symlink = None

477

 

        try:

478

 

            this.merge_from_branch(other.branch)

479

 

        finally:

480

 

            if os_symlink:

481

 

                os.symlink = os_symlink

482

 

        self.assertContainsRe(

483

 

            log.getvalue(),

484

 

            b'Unable to create symlink "foo" on this filesystem')

485

 

 

486

436

    def test_auto_resolve_dir(self):

487

437

        tree = self.make_branch_and_tree('tree')

488

438

        self.build_tree(['tree/hello/'])

489

439

        tree.add('hello', b'hello-id')

490

 

        file_conflict = conflicts.TextConflict('hello', b'hello-id')

491

 

        tree.set_conflicts(conflicts.ConflictList([file_conflict]))

492

 

        remaining, resolved = self._auto_resolve(tree)

493

 

        self.assertEqual(

494

 

            remaining,

495

 

            conflicts.ConflictList([conflicts.TextConflict(u'hello', 'hello-id')]))

496

 

        self.assertEqual(resolved, [])

497

 

 

498

 

    def test_auto_resolve_missing(self):

499

 

        tree = self.make_branch_and_tree('tree')

500

 

        file_conflict = conflicts.TextConflict('hello', b'hello-id')

501

 

        tree.set_conflicts(conflicts.ConflictList([file_conflict]))

502

 

        remaining, resolved = self._auto_resolve(tree)

503

 

        self.assertEqual(remaining, [])

504

 

        self.assertEqual(

505

 

            resolved,

506

 

            conflicts.ConflictList([conflicts.TextConflict(u'hello', 'hello-id')]))

 

440

        file_conflict = conflicts.TextConflict('file', b'hello-id')

 

441

        tree.set_conflicts(conflicts.ConflictList([file_conflict]))

 

442

        tree.auto_resolve()

 

443

 

 

444

 

 

445

class TestFindTrees(TestCaseWithTransport):

 

446

 

 

447

    def test_find_trees(self):

 

448

        self.make_branch_and_tree('foo')

 

449

        self.make_branch_and_tree('foo/bar')

 

450

        # Sticking a tree inside a control dir is heinous, so let's skip it

 

451

        self.make_branch_and_tree('foo/.bzr/baz')

 

452

        self.make_branch('qux')

 

453

        trees = workingtree.WorkingTree.find_trees('.')

 

454

        self.assertEqual(2, len(list(trees)))

507

455

 

508

456

 

509

457

class TestStoredUncommitted(TestCaseWithTransport):

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0