/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_shelf.py

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

• reverse the comparison (6822 to 5200.3.2)
• stop comparing with revision 5200.3.2

Show diffs side-by-side

added

removed

breezy/tests/test_shelf.py

1

 

# Copyright (C) 2008, 2009, 2010 Canonical Ltd

 

1

# Copyright (C) 2008-2011 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

16

16

 

17

17

import os

18

18

 

19

 

from bzrlib import (

 

19

from .. import (

20

20

    errors,

21

21

    osutils,

22

 

    pack,

23

22

    shelf,

24

23

    tests,

25

24

    transform,

26

25

    workingtree,

27

26

    )

 

27

from ..bzr import (

 

28

    pack,

 

29

    )

 

30

from . import (

 

31

    features,

 

32

    )

28

33

 

29

34

 

30

35

EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"

38

43

               "17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")

39

44

 

40

45

 

 

46

class TestErrors(tests.TestCase):

 

47

 

 

48

    def test_invalid_shelf_id(self):

 

49

        invalid_id = "foo"

 

50

        err = shelf.InvalidShelfId(invalid_id)

 

51

        self.assertEqual('"foo" is not a valid shelf id, '

 

52

                         'try a number instead.', str(err))

 

53

 

 

54

 

41

55

class TestPrepareShelf(tests.TestCaseWithTransport):

42

56

 

43

57

    def prepare_shelve_rename(self):

187

201

 

188

202

    def check_shelve_creation(self, creator, tree):

189

203

        self.assertRaises(StopIteration,

190

 

                          tree.iter_entries_by_dir(['foo-id']).next)

 

204

                          next, tree.iter_entries_by_dir(['foo-id']))

191

205

        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')

192

206

        self.assertEqual('foo-id',

193

207

                         creator.shelf_transform.final_file_id(s_trans_id))

194

 

        self.failIfExists('foo')

195

 

        self.failIfExists('bar')

 

208

        self.assertPathDoesNotExist('foo')

 

209

        self.assertPathDoesNotExist('bar')

196

210

        self.assertShelvedFileEqual('a\n', creator, 'foo-id')

197

211

        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')

198

212

        self.assertEqual('directory',

214

228

 

215

229

    def _test_shelve_symlink_creation(self, link_name, link_target,

216

230

                                      shelve_change=False):

217

 

        self.requireFeature(tests.SymlinkFeature)

 

231

        self.requireFeature(features.SymlinkFeature)

218

232

        tree = self.make_branch_and_tree('.')

219

233

        tree.lock_write()

220

234

        self.addCleanup(tree.unlock)

231

245

            creator.shelve_creation('foo-id')

232

246

        creator.transform()

233

247

        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')

234

 

        self.failIfExists(link_name)

 

248

        self.assertPathDoesNotExist(link_name)

235

249

        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)

236

250

        self.assertEqual(link_target, osutils.readlink(limbo_name))

237

251

        ptree = creator.shelf_transform.get_preview_tree()

238

 

        self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))

 

252

        self.assertEqual(

 

253

                link_target,

 

254

                ptree.get_symlink_target(ptree.id2path('foo-id'), 'foo-id'))

239

255

 

240

256

    def test_shelve_symlink_creation(self):

241

257

        self._test_shelve_symlink_creation('foo', 'bar')

242

258

 

243

259

    def test_shelve_unicode_symlink_creation(self):

244

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

260

        self.requireFeature(features.UnicodeFilenameFeature)

245

261

        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',

246

262

                                           u'b\N{Euro Sign}ar')

247

263

 

251

267

    def _test_shelve_symlink_target_change(self, link_name,

252

268

                                           old_target, new_target,

253

269

                                           shelve_change=False):

254

 

        self.requireFeature(tests.SymlinkFeature)

 

270

        self.requireFeature(features.SymlinkFeature)

255

271

        tree = self.make_branch_and_tree('.')

256

272

        tree.lock_write()

257

273

        self.addCleanup(tree.unlock)

276

292

        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)

277

293

        self.assertEqual(new_target, osutils.readlink(limbo_name))

278

294

        ptree = creator.shelf_transform.get_preview_tree()

279

 

        self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))

 

295

        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path('foo-id')))

280

296

 

281

297

    def test_shelve_symlink_target_change(self):

282

298

        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')

283

299

 

284

300

    def test_shelve_unicode_symlink_target_change(self):

285

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

301

        self.requireFeature(features.UnicodeFilenameFeature)

286

302

        self._test_shelve_symlink_target_change(

287

303

            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')

288

304

 

305

321

        creator.shelve_creation('foo-id')

306

322

        creator.transform()

307

323

        self.assertRaises(StopIteration,

308

 

                          tree.iter_entries_by_dir(['foo-id']).next)

 

324

                          next, tree.iter_entries_by_dir(['foo-id']))

309

325

        self.assertShelvedFileEqual('', creator, 'foo-id')

310

326

        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')

311

327

        self.assertEqual('foo-id',

312

328

                         creator.shelf_transform.final_file_id(s_trans_id))

313

 

        self.failIfExists('foo')

 

329

        self.assertPathDoesNotExist('foo')

314

330

 

315

331

    def prepare_shelve_deletion(self):

316

332

        tree = self.make_branch_and_tree('tree')

319

335

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

320

336

        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])

321

337

        tree.commit('Added file and directory')

322

 

        tree.unversion(['foo-id', 'bar-id'])

 

338

        tree.unversion(['foo', 'foo/bar'])

323

339

        os.unlink('tree/foo/bar')

324

340

        os.rmdir('tree/foo')

325

341

        creator = shelf.ShelfCreator(tree, tree.basis_tree())

330

346

        return creator, tree

331

347

 

332

348

    def check_shelve_deletion(self, tree):

333

 

        self.assertTrue('foo-id' in tree)

334

 

        self.assertTrue('bar-id' in tree)

 

349

        self.assertTrue(tree.has_id('foo-id'))

 

350

        self.assertTrue(tree.has_id('bar-id'))

335

351

        self.assertFileEqual('baz', 'tree/foo/bar')

336

352

 

337

353

    def test_shelve_deletion(self):

362

378

                         sorted(list(creator.iter_shelvable())))

363

379

        creator.shelve_deletion('foo-id')

364

380

        creator.transform()

365

 

        self.failUnlessExists('tree/foo')

 

381

        self.assertPathExists('tree/foo')

366

382

 

367

383

    def prepare_shelve_change_kind(self):

368

384

        tree = self.make_branch_and_tree('tree')

412

428

        self.build_tree(['tree/foo',])

413

429

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

414

430

        tree.commit('Added file and directory')

415

 

        tree.unversion(['foo-id'])

 

431

        tree.unversion(['foo'])

416

432

        tree.lock_tree_write()

417

433

        self.addCleanup(tree.unlock)

418

434

        creator = shelf.ShelfCreator(tree, tree.basis_tree())

421

437

                         sorted(list(creator.iter_shelvable())))

422

438

        creator.shelve_deletion('foo-id')

423

439

        creator.transform()

424

 

        self.failUnlessExists('tree/foo')

 

440

        self.assertPathExists('tree/foo')

425

441

 

426

442

    def test_shelve_serialization(self):

427

443

        tree = self.make_branch_and_tree('.')

462

478

        self.addCleanup(tt.finalize)

463

479

        records = iter(parser.read_pending_records())

464

480

        #skip revision-id

465

 

        records.next()

 

481

        next(records)

466

482

        tt.deserialize(records)

467

483

 

468

484

    def test_shelve_unversioned(self):

561

577

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

562

578

        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])

563

579

        tree.commit('Added file and directory')

564

 

        tree.unversion(['foo-id', 'bar-id'])

 

580

        tree.unversion(['foo', 'foo/bar'])

565

581

        os.unlink('tree/foo/bar')

566

582

        os.rmdir('tree/foo')

567

583

        creator = shelf.ShelfCreator(tree, tree.basis_tree())

568

584

        list(creator.iter_shelvable())

569

585

        creator.shelve_deletion('foo-id')

570

586

        creator.shelve_deletion('bar-id')

571

 

        shelf_file = open('shelf', 'w+b')

572

 

        self.addCleanup(shelf_file.close)

573

 

        creator.write_shelf(shelf_file)

574

 

        creator.transform()

575

 

        creator.finalize()

 

587

        with open('shelf', 'w+b') as shelf_file:

 

588

            creator.write_shelf(shelf_file)

 

589

            creator.transform()

 

590

            creator.finalize()

576

591

        # validate the test setup

577

 

        self.assertTrue('foo-id' in tree)

578

 

        self.assertTrue('bar-id' in tree)

 

592

        self.assertTrue(tree.has_id('foo-id'))

 

593

        self.assertTrue(tree.has_id('bar-id'))

579

594

        self.assertFileEqual('baz', 'tree/foo/bar')

580

 

        shelf_file.seek(0)

581

 

        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)

582

 

        self.addCleanup(unshelver.finalize)

583

 

        unshelver.make_merger().do_merge()

584

 

        self.assertFalse('foo-id' in tree)

585

 

        self.assertFalse('bar-id' in tree)

 

595

        with open('shelf', 'r+b') as shelf_file:

 

596

            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)

 

597

            self.addCleanup(unshelver.finalize)

 

598

            unshelver.make_merger().do_merge()

 

599

        self.assertFalse(tree.has_id('foo-id'))

 

600

        self.assertFalse(tree.has_id('bar-id'))

586

601

 

587

602

    def test_unshelve_base(self):

588

603

        tree = self.make_branch_and_tree('tree')

618

633

                                                                'foo'))])

619

634

        shelf_file = open('shelf', 'rb')

620

635

        self.addCleanup(shelf_file.close)

621

 

        e = self.assertRaises(errors.ShelfCorrupt,

 

636

        e = self.assertRaises(shelf.ShelfCorrupt,

622

637

                              shelf.Unshelver.from_tree_and_shelf, tree,

623

638

                              shelf_file)

624

639

        self.assertEqual('Shelf corrupt.', str(e))

625

640

 

 

641

    def test_unshelve_subdir_in_now_removed_dir(self):

 

642

        tree = self.make_branch_and_tree('.')

 

643

        self.addCleanup(tree.lock_write().unlock)

 

644

        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])

 

645

        tree.add(['dir'], ['dir-id'])

 

646

        tree.commit('versioned dir')

 

647

        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])

 

648

        creator = shelf.ShelfCreator(tree, tree.basis_tree())

 

649

        self.addCleanup(creator.finalize)

 

650

        for change in creator.iter_shelvable():

 

651

            creator.shelve_change(change)

 

652

        shelf_manager = tree.get_shelf_manager()

 

653

        shelf_id = shelf_manager.shelve_changes(creator)

 

654

        self.assertPathDoesNotExist('dir/subdir')

 

655

        tree.remove(['dir'])

 

656

        unshelver = shelf_manager.get_unshelver(shelf_id)

 

657

        self.addCleanup(unshelver.finalize)

 

658

        unshelver.make_merger().do_merge()

 

659

        self.assertPathExists('dir/subdir/foo')

 

660

        self.assertEqual('dir-id', tree.path2id('dir'))

 

661

        self.assertEqual('subdir-id', tree.path2id('dir/subdir'))

 

662

        self.assertEqual('foo-id', tree.path2id('dir/subdir/foo'))

 

663

 

626

664

 

627

665

class TestShelfManager(tests.TestCaseWithTransport):

628

666

 

706

744

 

707

745

    def test_read_non_existant(self):

708

746

        manager = self.get_manager()

709

 

        e = self.assertRaises(errors.NoSuchShelfId, manager.read_shelf, 1)

 

747

        e = self.assertRaises(shelf.NoSuchShelfId, manager.read_shelf, 1)

710

748

        self.assertEqual('No changes are shelved with id "1".', str(e))

711

749

 

712

750

    def test_shelve_changes(self):

723

761

        creator.shelve_creation('foo-id')

724

762

        shelf_manager = tree.get_shelf_manager()

725

763

        shelf_id = shelf_manager.shelve_changes(creator)

726

 

        self.failIfExists('tree/foo')

 

764

        self.assertPathDoesNotExist('tree/foo')

727

765

        unshelver = shelf_manager.get_unshelver(shelf_id)

728

766

        self.addCleanup(unshelver.finalize)

729

767

        unshelver.make_merger().do_merge()

• Older »

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