~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

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

Show diffs side-by-side

added

removed

bzrlib/tests/test_transform.py

36

36

from bzrlib.osutils import file_kind, pathjoin

37

37

from bzrlib.merge import Merge3Merger

38

38

from bzrlib.tests import (

 

39

    CaseInsensitiveFilesystemFeature,

39

40

    SymlinkFeature,

40

41

    TestCase,

41

42

    TestCaseInTempDir,

44

45

from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 

45

46

                              resolve_conflicts, cook_conflicts, 

46

47

                              find_interesting, build_tree, get_backup_name,

47

 

                              change_entry, _FileMover)

 

48

                              change_entry, _FileMover, resolve_checkout)

48

49

 

49

50

 

50

51

class TestTreeTransform(tests.TestCaseWithTransport):

84

85

        self.assertRaises(ExistingPendingDeletion, self.get_transform)

85

86

 

86

87

    def test_build(self):

87

 

        transform, root = self.get_transform() 

 

88

        transform, root = self.get_transform()

 

89

        self.wt.lock_tree_write()

 

90

        self.addCleanup(self.wt.unlock)

88

91

        self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)

89

92

        imaginary_id = transform.trans_id_tree_path('imaginary')

90

93

        imaginary_id2 = transform.trans_id_tree_path('imaginary/')

127

130

 

128

131

    def test_convenience(self):

129

132

        transform, root = self.get_transform()

 

133

        self.wt.lock_tree_write()

 

134

        self.addCleanup(self.wt.unlock)

130

135

        trans_id = transform.new_file('name', root, 'contents', 

131

136

                                      'my_pretties', True)

132

137

        oz = transform.new_directory('oz', root, 'oz-id')

233

238

        transform3.adjust_path('tip', root_id, tip_id)

234

239

        transform3.apply()

235

240

 

 

241

    def test_conflict_on_case_insensitive(self):

 

242

        tree = self.make_branch_and_tree('tree')

 

243

        # Don't try this at home, kids!

 

244

        # Force the tree to report that it is case sensitive, for conflict

 

245

        # resolution tests

 

246

        tree.case_sensitive = True

 

247

        transform = TreeTransform(tree)

 

248

        self.addCleanup(transform.finalize)

 

249

        transform.new_file('file', transform.root, 'content')

 

250

        transform.new_file('FiLe', transform.root, 'content')

 

251

        result = transform.find_conflicts()

 

252

        self.assertEqual([], result)

 

253

        # Force the tree to report that it is case insensitive, for conflict

 

254

        # generation tests

 

255

        tree.case_sensitive = False

 

256

        result = transform.find_conflicts()

 

257

        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)

 

258

 

 

259

    def test_conflict_on_case_insensitive_existing(self):

 

260

        tree = self.make_branch_and_tree('tree')

 

261

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

 

262

        # Don't try this at home, kids!

 

263

        # Force the tree to report that it is case sensitive, for conflict

 

264

        # resolution tests

 

265

        tree.case_sensitive = True

 

266

        transform = TreeTransform(tree)

 

267

        self.addCleanup(transform.finalize)

 

268

        transform.new_file('file', transform.root, 'content')

 

269

        result = transform.find_conflicts()

 

270

        self.assertEqual([], result)

 

271

        # Force the tree to report that it is case insensitive, for conflict

 

272

        # generation tests

 

273

        tree.case_sensitive = False

 

274

        result = transform.find_conflicts()

 

275

        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)

 

276

 

 

277

    def test_resolve_case_insensitive_conflict(self):

 

278

        tree = self.make_branch_and_tree('tree')

 

279

        # Don't try this at home, kids!

 

280

        # Force the tree to report that it is case insensitive, for conflict

 

281

        # resolution tests

 

282

        tree.case_sensitive = False

 

283

        transform = TreeTransform(tree)

 

284

        self.addCleanup(transform.finalize)

 

285

        transform.new_file('file', transform.root, 'content')

 

286

        transform.new_file('FiLe', transform.root, 'content')

 

287

        resolve_conflicts(transform)

 

288

        transform.apply()

 

289

        self.failUnlessExists('tree/file')

 

290

        self.failUnlessExists('tree/FiLe.moved')

 

291

 

 

292

    def test_resolve_checkout_case_conflict(self):

 

293

        tree = self.make_branch_and_tree('tree')

 

294

        # Don't try this at home, kids!

 

295

        # Force the tree to report that it is case insensitive, for conflict

 

296

        # resolution tests

 

297

        tree.case_sensitive = False

 

298

        transform = TreeTransform(tree)

 

299

        self.addCleanup(transform.finalize)

 

300

        transform.new_file('file', transform.root, 'content')

 

301

        transform.new_file('FiLe', transform.root, 'content')

 

302

        resolve_conflicts(transform,

 

303

                          pass_func=lambda t, c: resolve_checkout(t, c, []))

 

304

        transform.apply()

 

305

        self.failUnlessExists('tree/file')

 

306

        self.failUnlessExists('tree/FiLe.moved')

 

307

 

 

308

    def test_apply_case_conflict(self):

 

309

        """Ensure that a transform with case conflicts can always be applied"""

 

310

        tree = self.make_branch_and_tree('tree')

 

311

        transform = TreeTransform(tree)

 

312

        self.addCleanup(transform.finalize)

 

313

        transform.new_file('file', transform.root, 'content')

 

314

        transform.new_file('FiLe', transform.root, 'content')

 

315

        dir = transform.new_directory('dir', transform.root)

 

316

        transform.new_file('dirfile', dir, 'content')

 

317

        transform.new_file('dirFiLe', dir, 'content')

 

318

        resolve_conflicts(transform)

 

319

        transform.apply()

 

320

        self.failUnlessExists('tree/file')

 

321

        if not os.path.exists('tree/FiLe.moved'):

 

322

            self.failUnlessExists('tree/FiLe')

 

323

        self.failUnlessExists('tree/dir/dirfile')

 

324

        if not os.path.exists('tree/dir/dirFiLe.moved'):

 

325

            self.failUnlessExists('tree/dir/dirFiLe')

 

326

 

 

327

    def test_case_insensitive_limbo(self):

 

328

        tree = self.make_branch_and_tree('tree')

 

329

        # Don't try this at home, kids!

 

330

        # Force the tree to report that it is case insensitive

 

331

        tree.case_sensitive = False

 

332

        transform = TreeTransform(tree)

 

333

        self.addCleanup(transform.finalize)

 

334

        dir = transform.new_directory('dir', transform.root)

 

335

        first = transform.new_file('file', dir, 'content')

 

336

        second = transform.new_file('FiLe', dir, 'content')

 

337

        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')

 

338

        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')

 

339

 

236

340

    def test_add_del(self):

237

341

        start, root = self.get_transform()

238

342

        start.new_directory('a', root, 'a')

410

514

        self.assertEqual(os.readlink(self.wt.abspath('oz/wizard')),

411

515

                         'wizard-target')

412

516

 

 

517

    def test_unable_create_symlink(self):

 

518

        def tt_helper():

 

519

            wt = self.make_branch_and_tree('.')

 

520

            tt = TreeTransform(wt)  # TreeTransform obtains write lock

 

521

            try:

 

522

                tt.new_symlink('foo', tt.root, 'bar')

 

523

                tt.apply()

 

524

            finally:

 

525

                wt.unlock()

 

526

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

 

527

        os.symlink = None

 

528

        try:

 

529

            err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)

 

530

            self.assertEquals(

 

531

                "Unable to create symlink 'foo' on this platform",

 

532

                str(err))

 

533

        finally:

 

534

            if os_symlink:

 

535

                os.symlink = os_symlink

 

536

 

413

537

    def get_conflicted(self):

414

538

        create,root = self.get_transform()

415

539

        create.new_file('dorothy', root, 'dorothy', 'dorothy-id')

558

682

        """

559

683

        transform, root = self.get_transform()

560

684

        wt = transform._tree

 

685

        wt.lock_read()

 

686

        self.addCleanup(wt.unlock)

561

687

        transform.new_file('set_on_creation', root, 'Set on creation', 'soc',

562

688

                           True)

563

689

        sac = transform.new_file('set_after_creation', root,

963

1089

        self.callDeprecated([txt], change_entry, None, None, None, None, None,

964

1090

            None, None, None)

965

1091

 

 

1092

    def test_case_insensitive_clash(self):

 

1093

        self.requireFeature(CaseInsensitiveFilesystemFeature)

 

1094

        def tt_helper():

 

1095

            wt = self.make_branch_and_tree('.')

 

1096

            tt = TreeTransform(wt)  # TreeTransform obtains write lock

 

1097

            try:

 

1098

                tt.new_file('foo', tt.root, 'bar')

 

1099

                tt.new_file('Foo', tt.root, 'spam')

 

1100

                # Lie to tt that we've already resolved all conflicts.

 

1101

                tt.apply(no_conflicts=True)

 

1102

            except:

 

1103

                wt.unlock()

 

1104

                raise

 

1105

        err = self.assertRaises(errors.FileExists, tt_helper)

 

1106

        self.assertContainsRe(str(err),

 

1107

            "^File exists: .+/foo")

 

1108

 

 

1109

    def test_two_directories_clash(self):

 

1110

        def tt_helper():

 

1111

            wt = self.make_branch_and_tree('.')

 

1112

            tt = TreeTransform(wt)  # TreeTransform obtains write lock

 

1113

            try:

 

1114

                foo_1 = tt.new_directory('foo', tt.root)

 

1115

                tt.new_directory('bar', foo_1)

 

1116

                foo_2 = tt.new_directory('foo', tt.root)

 

1117

                tt.new_directory('baz', foo_2)

 

1118

                # Lie to tt that we've already resolved all conflicts.

 

1119

                tt.apply(no_conflicts=True)

 

1120

            except:

 

1121

                wt.unlock()

 

1122

                raise

 

1123

        err = self.assertRaises(errors.FileExists, tt_helper)

 

1124

        self.assertContainsRe(str(err),

 

1125

            "^File exists: .+/foo")

 

1126

 

 

1127

    def test_two_directories_clash_finalize(self):

 

1128

        def tt_helper():

 

1129

            wt = self.make_branch_and_tree('.')

 

1130

            tt = TreeTransform(wt)  # TreeTransform obtains write lock

 

1131

            try:

 

1132

                foo_1 = tt.new_directory('foo', tt.root)

 

1133

                tt.new_directory('bar', foo_1)

 

1134

                foo_2 = tt.new_directory('foo', tt.root)

 

1135

                tt.new_directory('baz', foo_2)

 

1136

                # Lie to tt that we've already resolved all conflicts.

 

1137

                tt.apply(no_conflicts=True)

 

1138

            except:

 

1139

                tt.finalize()

 

1140

                raise

 

1141

        err = self.assertRaises(errors.FileExists, tt_helper)

 

1142

        self.assertContainsRe(str(err),

 

1143

            "^File exists: .+/foo")

 

1144

 

966

1145

 

967

1146

class TransformGroup(object):

 

1147

 

968

1148

    def __init__(self, dirname, root_id):

969

1149

        self.name = dirname

970

1150

        os.mkdir(dirname)

1167

1347

 

1168

1348

class TestBuildTree(tests.TestCaseWithTransport):

1169

1349

 

1170

 

    def test_build_tree(self):

 

1350

    def test_build_tree_with_symlinks(self):

1171

1351

        self.requireFeature(SymlinkFeature)

1172

1352

        os.mkdir('a')

1173

1353

        a = BzrDir.create_standalone_workingtree('a')

1337

1517

        object.__init__(self)

1338

1518

        self.name = "name"

1339

1519

 

 

1520

 

1340

1521

class TestGetBackupName(TestCase):

1341

1522

    def test_get_backup_name(self):

1342

1523

        tt = MockTransform()

1396

1577

        mover.rename('c/e', 'c/d')

1397

1578

        try:

1398

1579

            mover.rename('a', 'c')

1399

 

        except OSError, e:

 

1580

        except errors.FileExists, e:

1400

1581

            mover.rollback()

1401

1582

        self.failUnlessExists('a')

1402

1583

        self.failUnlessExists('c/d')

1469

1650

                          _mover=self.ExceptionFileMover(bad_target='d'))

1470

1651

        self.failUnlessExists('a')

1471

1652

        self.failUnlessExists('a/b')

 

1653

 

 

1654

    def test_resolve_no_parent(self):

 

1655

        wt = self.make_branch_and_tree('.')

 

1656

        tt = TreeTransform(wt)

 

1657

        self.addCleanup(tt.finalize)

 

1658

        parent = tt.trans_id_file_id('parent-id')

 

1659

        tt.new_file('file', parent, 'Contents')

 

1660

        resolve_conflicts(tt)

• Older »

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