~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_inv.py

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

Show diffs side-by-side

added

removed

bzrlib/tests/test_inv.py

54

54

            'apply_delta':apply_inventory_Repository_add_inventory_by_delta,

55

55

            'format':format}))

56

56

    for format in workingtree_formats():

57

 

        scenarios.append((str(format.__class__.__name__), {

 

57

        scenarios.append(

 

58

            (str(format.__class__.__name__) + ".update_basis_by_delta", {

58

59

            'apply_delta':apply_inventory_WT_basis,

59

60

            'format':format}))

 

61

        scenarios.append(

 

62

            (str(format.__class__.__name__) + ".apply_inventory_delta", {

 

63

            'apply_delta':apply_inventory_WT,

 

64

            'format':format}))

60

65

    return multiply_tests(to_adapt, scenarios, result)

61

66

 

62

67

 

71

76

    return basis

72

77

 

73

78

 

 

79

def apply_inventory_WT(self, basis, delta):

 

80

    """Apply delta to basis and return the result.

 

81

 

 

82

    This sets the tree state to be basis, and then calls apply_inventory_delta.

 

83

    

 

84

    :param basis: An inventory to be used as the basis.

 

85

    :param delta: The inventory delta to apply:

 

86

    :return: An inventory resulting from the application.

 

87

    """

 

88

    control = self.make_bzrdir('tree', format=self.format._matchingbzrdir)

 

89

    control.create_repository()

 

90

    control.create_branch()

 

91

    tree = self.format.initialize(control)

 

92

    tree.lock_write()

 

93

    try:

 

94

        tree._write_inventory(basis)

 

95

    finally:

 

96

        tree.unlock()

 

97

    # Fresh object, reads disk again.

 

98

    tree = tree.bzrdir.open_workingtree()

 

99

    tree.lock_write()

 

100

    try:

 

101

        tree.apply_inventory_delta(delta)

 

102

    finally:

 

103

        tree.unlock()

 

104

    # reload tree - ensure we get what was written.

 

105

    tree = tree.bzrdir.open_workingtree()

 

106

    tree.lock_read()

 

107

    self.addCleanup(tree.unlock)

 

108

    # One could add 'tree._validate' here but that would cause 'early' failues 

 

109

    # as far as higher level code is concerned. Possibly adding an

 

110

    # expect_fail parameter to this function and if that is False then do a

 

111

    # validate call.

 

112

    return tree.inventory

 

113

 

 

114

 

74

115

def apply_inventory_WT_basis(self, basis, delta):

75

116

    """Apply delta to basis and return the result.

76

117

 

118

159

        paths = {}

119

160

        parents = set()

120

161

        for old, new, id, entry in delta:

121

 

            if entry is None:

 

162

            if None in (new, entry):

122

163

                continue

123

164

            paths[new] = (entry.file_id, entry.kind)

124

165

            parents.add(osutils.dirname(new))

236

277

        inv2 = self.get_empty_inventory(inv)

237

278

        self.assertEqual([], inv2._make_delta(inv))

238

279

 

 

280

    def test_None_file_id(self):

 

281

        inv = self.get_empty_inventory()

 

282

        dir1 = inventory.InventoryDirectory(None, 'dir1', inv.root.file_id)

 

283

        dir1.revision = 'result'

 

284

        delta = [(None, u'dir1', None, dir1)]

 

285

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

286

            inv, delta)

 

287

 

 

288

    def test_unicode_file_id(self):

 

289

        inv = self.get_empty_inventory()

 

290

        dir1 = inventory.InventoryDirectory(u'dirid', 'dir1', inv.root.file_id)

 

291

        dir1.revision = 'result'

 

292

        delta = [(None, u'dir1', dir1.file_id, dir1)]

 

293

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

294

            inv, delta)

 

295

 

239

296

    def test_repeated_file_id(self):

240

297

        inv = self.get_empty_inventory()

241

298

        file1 = inventory.InventoryFile('id', 'path1', inv.root.file_id)

296

353

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

297

354

            inv, delta)

298

355

 

 

356

    def test_mismatched_new_path_entry_None(self):

 

357

        inv = self.get_empty_inventory()

 

358

        delta = [(None, u'path', 'id', None)]

 

359

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

360

            inv, delta)

 

361

 

 

362

    def test_mismatched_new_path_None_entry(self):

 

363

        inv = self.get_empty_inventory()

 

364

        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)

 

365

        file1.revision = 'result'

 

366

        file1.text_size = 0

 

367

        file1.text_sha1 = ""

 

368

        delta = [(u"path", None, 'id1', file1)]

 

369

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

370

            inv, delta)

 

371

 

299

372

    def test_parent_is_not_directory(self):

300

373

        inv = self.get_empty_inventory()

301

374

        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)

321

394

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

322

395

            inv, delta)

323

396

 

 

397

    def test_new_parent_path_has_wrong_id(self):

 

398

        inv = self.get_empty_inventory()

 

399

        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)

 

400

        parent1.revision = 'result'

 

401

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

 

402

        parent2.revision = 'result'

 

403

        file1 = inventory.InventoryFile('id', 'path', 'p-2')

 

404

        file1.revision = 'result'

 

405

        file1.text_size = 0

 

406

        file1.text_sha1 = ""

 

407

        inv.add(parent1)

 

408

        inv.add(parent2)

 

409

        # This delta claims that file1 is at dir/path, but actually its at

 

410

        # dir2/path if you follow the inventory parent structure.

 

411

        delta = [(None, u'dir/path', 'id', file1)]

 

412

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

413

            inv, delta)

 

414

 

 

415

    def test_old_parent_path_is_wrong(self):

 

416

        inv = self.get_empty_inventory()

 

417

        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)

 

418

        parent1.revision = 'result'

 

419

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

 

420

        parent2.revision = 'result'

 

421

        file1 = inventory.InventoryFile('id', 'path', 'p-2')

 

422

        file1.revision = 'result'

 

423

        file1.text_size = 0

 

424

        file1.text_sha1 = ""

 

425

        inv.add(parent1)

 

426

        inv.add(parent2)

 

427

        inv.add(file1)

 

428

        # This delta claims that file1 was at dir/path, but actually it was at

 

429

        # dir2/path if you follow the inventory parent structure.

 

430

        delta = [(u'dir/path', None, 'id', None)]

 

431

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

432

            inv, delta)

 

433

 

 

434

    def test_old_parent_path_is_for_other_id(self):

 

435

        inv = self.get_empty_inventory()

 

436

        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)

 

437

        parent1.revision = 'result'

 

438

        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)

 

439

        parent2.revision = 'result'

 

440

        file1 = inventory.InventoryFile('id', 'path', 'p-2')

 

441

        file1.revision = 'result'

 

442

        file1.text_size = 0

 

443

        file1.text_sha1 = ""

 

444

        file2 = inventory.InventoryFile('id2', 'path', 'p-1')

 

445

        file2.revision = 'result'

 

446

        file2.text_size = 0

 

447

        file2.text_sha1 = ""

 

448

        inv.add(parent1)

 

449

        inv.add(parent2)

 

450

        inv.add(file1)

 

451

        inv.add(file2)

 

452

        # This delta claims that file1 was at dir/path, but actually it was at

 

453

        # dir2/path if you follow the inventory parent structure. At dir/path

 

454

        # is another entry we should not delete.

 

455

        delta = [(u'dir/path', None, 'id', None)]

 

456

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

457

            inv, delta)

 

458

 

 

459

    def test_add_existing_id_new_path(self):

 

460

        inv = self.get_empty_inventory()

 

461

        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)

 

462

        parent1.revision = 'result'

 

463

        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)

 

464

        parent2.revision = 'result'

 

465

        inv.add(parent1)

 

466

        delta = [(None, u'dir2', 'p-1', parent2)]

 

467

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

468

            inv, delta)

 

469

 

 

470

    def test_add_new_id_existing_path(self):

 

471

        inv = self.get_empty_inventory()

 

472

        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)

 

473

        parent1.revision = 'result'

 

474

        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)

 

475

        parent2.revision = 'result'

 

476

        inv.add(parent1)

 

477

        delta = [(None, u'dir1', 'p-2', parent2)]

 

478

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

479

            inv, delta)

 

480

 

 

481

    def test_remove_dir_leaving_dangling_child(self):

 

482

        inv = self.get_empty_inventory()

 

483

        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)

 

484

        dir1.revision = 'result'

 

485

        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')

 

486

        dir2.revision = 'result'

 

487

        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')

 

488

        dir3.revision = 'result'

 

489

        inv.add(dir1)

 

490

        inv.add(dir2)

 

491

        inv.add(dir3)

 

492

        delta = [(u'dir1', None, 'p-1', None),

 

493

            (u'dir1/child2', None, 'p-3', None)]

 

494

        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,

 

495

            inv, delta)

 

496

 

324

497

 

325

498

class TestInventoryEntry(TestCase):

326

499

 

738

911

        inv.add_path("", "directory", "myrootid", None)

739

912

        inv.revision_id = "expectedid"

740

913

        reference_inv = CHKInventory.from_inventory(chk_bytes, inv)

741

 

        delta = [(None, "",  "myrootid", inv.root)]

 

914

        delta = [("", None, base_inv.root.file_id, None),

 

915

            (None, "",  "myrootid", inv.root)]

742

916

        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")

743

917

        self.assertEquals(reference_inv.root, new_inv.root)

744

918

 

• Older »

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