/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_tree.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_tree.py

83

83

    calls = []

84

84

 

85

85

    def compare(self, want_unchanged=False, specific_files=None,

86

 

        extra_trees=None, require_versioned=False, include_root=False,

87

 

        want_unversioned=False):

 

86

                extra_trees=None, require_versioned=False, include_root=False,

 

87

                want_unversioned=False):

88

88

        self.calls.append(

89

89

            ('compare', self.source, self.target, want_unchanged,

90

90

             specific_files, extra_trees, require_versioned,

115

115

                              'require', True)

116

116

            # pass in all optional arguments by keyword

117

117

            tree.changes_from(tree2,

118

 

                specific_files='specific',

119

 

                want_unchanged='unchanged',

120

 

                extra_trees='extra',

121

 

                require_versioned='require',

122

 

                include_root=True,

123

 

                want_unversioned=True,

124

 

                )

 

118

                              specific_files='specific',

 

119

                              want_unchanged='unchanged',

 

120

                              extra_trees='extra',

 

121

                              require_versioned='require',

 

122

                              include_root=True,

 

123

                              want_unversioned=True,

 

124

                              )

125

125

        finally:

126

126

            InterTree._optimisers = old_optimisers

127

127

        self.assertEqual(

128

128

            [

129

 

             ('compare', tree2, tree, False, None, None, False, False, False),

130

 

             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',

131

 

              'require', True, False),

132

 

             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',

133

 

              'require', True, True),

 

129

                ('compare', tree2, tree, False, None, None, False, False,

 

130

                    False),

 

131

                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',

 

132

                    'require', True, False),

 

133

                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',

 

134

                    'require', True, True),

134

135

            ], RecordingOptimiser.calls)

135

136

 

136

137

    def test_changes_from_with_root(self):

148

149

        self.build_tree(['known_file', 'unknown_file'])

149

150

        wt.add('known_file')

150

151

 

151

 

        self.assertRaises(errors.PathsNotVersionedError,

152

 

            wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',

153

 

            'unknown_file'], require_versioned=True)

 

152

        self.assertRaises(

 

153

            errors.PathsNotVersionedError,

 

154

            wt.changes_from, wt.basis_tree(), wt,

 

155

            specific_files=['known_file', 'unknown_file'],

 

156

            require_versioned=True)

154

157

 

155

158

        # we need to pass a known file with an unknown file to get this to

156

159

        # fail when expected.

157

160

        delta = wt.changes_from(wt.basis_tree(),

158

 

            specific_files=['known_file', 'unknown_file'],

159

 

            require_versioned=False)

 

161

                                specific_files=['known_file', 'unknown_file'],

 

162

                                require_versioned=False)

160

163

        self.assertEqual(len(delta.added), 1)

161

164

 

162

165

 

216

219

        else:

217

220

            self.assertIs(None, master_ie, 'master should not have an entry')

218

221

        self.assertEqual(len(exp_other_paths), len(other_values),

219

 

                            'Wrong number of other entries')

 

222

                         'Wrong number of other entries')

220

223

        other_paths = []

221

224

        other_file_ids = []

222

225

        for path, ie in other_values:

367

370

                                              second_tree])

368

371

        iterator = walker.iter_all()

369

372

        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)

370

 

        self.assertWalkerNext(u'a', b'a-id', True, [u'a', u'a', u'a'], iterator)

371

 

        self.assertWalkerNext(u'b', b'b-id', True, [u'b', u'b', u'b'], iterator)

372

 

        self.assertWalkerNext(u'c', b'c-id', False, [u'c', u'c', u'c'], iterator)

373

 

        self.assertWalkerNext(u'd', b'd-id', False, [None, u'd', u'd'], iterator)

374

 

        self.assertWalkerNext(u'e', b'e-id', False, [None, u'e', None], iterator)

 

373

        self.assertWalkerNext(u'a', b'a-id', True,

 

374

                              [u'a', u'a', u'a'], iterator)

 

375

        self.assertWalkerNext(u'b', b'b-id', True,

 

376

                              [u'b', u'b', u'b'], iterator)

 

377

        self.assertWalkerNext(u'c', b'c-id', False,

 

378

                              [u'c', u'c', u'c'], iterator)

 

379

        self.assertWalkerNext(u'd', b'd-id', False,

 

380

                              [None, u'd', u'd'], iterator)

 

381

        self.assertWalkerNext(u'e', b'e-id', False,

 

382

                              [None, u'e', None], iterator)

375

383

        self.assertRaises(StopIteration, next, iterator)

376

384

 

377

385

    def test_different_file_id_in_others(self):

403

411

        self.assertRaises(StopIteration, next, iterator)

404

412

 

405

413

    def assertLtByDirblock(self, lt_val, path1, path2):

406

 

        self.assertEqual(lt_val,

407

 

            _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))

 

414

        self.assertEqual(

 

415

            lt_val, _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))

408

416

 

409

417

    def test__lt_path_by_dirblock(self):

410

418

        # We only support Unicode strings at this point

411

 

        self.assertRaises(TypeError,

412

 

            _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')

 

419

        self.assertRaises(

 

420

            TypeError, _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')

413

421

        self.assertLtByDirblock(False, u'', u'')

414

422

        self.assertLtByDirblock(False, u'a', u'a')

415

423

        self.assertLtByDirblock(False, u'a/b', u'a/b')

472

480

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

473

481

        tree.add(['b'])

474

482

        self.assertEqual(

475

 

                'b',

476

 

                get_canonical_path(tree, 'b', lambda x: x.lower()))

 

483

            'b',

 

484

            get_canonical_path(tree, 'b', lambda x: x.lower()))

477

485

        self.assertEqual(

478

 

                'b',

479

 

                get_canonical_path(tree, 'B', lambda x: x.lower()))

 

486

            'b',

 

487

            get_canonical_path(tree, 'B', lambda x: x.lower()))

480

488

 

481

489

    def test_nonexistant_preserves_case(self):

482

490

        tree = self.make_branch_and_tree('tree')

483

491

        self.assertEqual(

484

 

                'b',

485

 

                get_canonical_path(tree, 'b', lambda x: x.lower()))

 

492

            'b',

 

493

            get_canonical_path(tree, 'b', lambda x: x.lower()))

486

494

        self.assertEqual(

487

 

                'B',

488

 

                get_canonical_path(tree, 'B', lambda x: x.lower()))

 

495

            'B',

 

496

            get_canonical_path(tree, 'B', lambda x: x.lower()))

489

497

 

490

498

    def test_in_directory_with_case(self):

491

499

        tree = self.make_branch_and_tree('tree')

492

500

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

493

501

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

494

502

        self.assertEqual(

495

 

                'a/b',

496

 

                get_canonical_path(tree, 'a/b', lambda x: x.lower()))

497

 

        self.assertEqual(

498

 

                'a/b',

499

 

                get_canonical_path(tree, 'A/B', lambda x: x.lower()))

500

 

        self.assertEqual(

501

 

                'a/b',

502

 

                get_canonical_path(tree, 'A/b', lambda x: x.lower()))

503

 

        self.assertEqual(

504

 

                'a/C',

505

 

                get_canonical_path(tree, 'A/C', lambda x: x.lower()))

 

503

            'a/b',

 

504

            get_canonical_path(tree, 'a/b', lambda x: x.lower()))

 

505

        self.assertEqual(

 

506

            'a/b',

 

507

            get_canonical_path(tree, 'A/B', lambda x: x.lower()))

 

508

        self.assertEqual(

 

509

            'a/b',

 

510

            get_canonical_path(tree, 'A/b', lambda x: x.lower()))

 

511

        self.assertEqual(

 

512

            'a/C',

 

513

            get_canonical_path(tree, 'A/C', lambda x: x.lower()))

• Older »

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