~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

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

• reverse the comparison (5590.1.2 to 5830.3.4)
• stop comparing with revision 5830.3.4

Show diffs side-by-side

added

removed

bzrlib/tests/test_workingtree.py

1

 

# Copyright (C) 2005-2011 Canonical Ltd

 

1

# Copyright (C) 2005-2010 Canonical Ltd

2

2

# Authors:  Robert Collins <robert.collins@canonical.com>

3

3

#

4

4

# This program is free software; you can redistribute it and/or modify

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

import os

 

19

 

18

20

from bzrlib import (

19

21

    bzrdir,

20

22

    conflicts,

21

23

    errors,

22

 

    symbol_versioning,

23

24

    transport,

24

25

    workingtree,

25

 

    workingtree_3,

26

 

    workingtree_4,

27

26

    )

28

27

from bzrlib.lockdir import LockDir

29

28

from bzrlib.mutabletree import needs_tree_write_lock

63

62

class TestDefaultFormat(TestCaseWithTransport):

64

63

 

65

64

    def test_get_set_default_format(self):

66

 

        old_format = workingtree.format_registry.get_default()

67

 

        # default is 6

68

 

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

69

 

        workingtree.format_registry.set_default(SampleTreeFormat())

70

 

        try:

71

 

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

72

 

            # which is not the default bzrdir format at this point

73

 

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

74

 

            dir.create_repository()

75

 

            dir.create_branch()

76

 

            result = dir.create_workingtree()

77

 

            self.assertEqual(result, 'A tree')

78

 

        finally:

79

 

            workingtree.format_registry.set_default(old_format)

80

 

        self.assertEqual(old_format, workingtree.format_registry.get_default())

81

 

 

82

 

    def test_get_set_default_format_by_key(self):

83

 

        old_format = workingtree.format_registry.get_default()

84

 

        # default is 6

85

 

        format = SampleTreeFormat()

86

 

        workingtree.format_registry.register(format)

87

 

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

88

 

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

89

 

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

90

 

        try:

91

 

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

92

 

            # which is not the default bzrdir format at this point

93

 

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

94

 

            dir.create_repository()

95

 

            dir.create_branch()

96

 

            result = dir.create_workingtree()

97

 

            self.assertEqual(result, 'A tree')

98

 

        finally:

99

 

            workingtree.format_registry.set_default_key(

100

 

                old_format.get_format_string())

101

 

        self.assertEqual(old_format, workingtree.format_registry.get_default())

 

65

        old_format = workingtree.WorkingTreeFormat.get_default_format()

 

66

        # default is 3

 

67

        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))

 

68

        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())

 

69

        try:

 

70

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

 

71

            # which is not the default bzrdir format at this point

 

72

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

 

73

            dir.create_repository()

 

74

            dir.create_branch()

 

75

            result = dir.create_workingtree()

 

76

            self.assertEqual(result, 'A tree')

 

77

        finally:

 

78

            workingtree.WorkingTreeFormat.set_default_format(old_format)

 

79

        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())

102

80

 

103

81

    def test_open(self):

104

82

        tree = self.make_branch_and_tree('.')

145

123

        return "opened tree."

146

124

 

147

125

 

148

 

class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):

149

 

    """A sample format that does not support use in a metadir.

150

 

 

151

 

    """

152

 

 

153

 

    def get_format_string(self):

154

 

        # Not usable in a metadir, so no format string

155

 

        return None

156

 

 

157

 

    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,

158

 

                   accelerator_tree=None, hardlink=False):

159

 

        raise NotImplementedError(self.initialize)

160

 

 

161

 

    def is_supported(self):

162

 

        return False

163

 

 

164

 

    def open(self, transport, _found=False):

165

 

        raise NotImplementedError(self.open)

166

 

 

167

 

 

168

126

class TestWorkingTreeFormat(TestCaseWithTransport):

169

127

    """Tests for the WorkingTreeFormat facility."""

170

128

 

171

 

    def test_find_format_string(self):

172

 

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

173

 

        branch = self.make_branch('branch')

174

 

        self.assertRaises(errors.NoWorkingTree,

175

 

            workingtree.WorkingTreeFormat.find_format_string, branch.bzrdir)

176

 

        transport = branch.bzrdir.get_workingtree_transport(None)

177

 

        transport.mkdir('.')

178

 

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

179

 

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

180

 

        # find_format_string just retrieves the name

181

 

        self.assertEquals("some format name",

182

 

            workingtree.WorkingTreeFormat.find_format_string(branch.bzrdir))

183

 

 

184

129

    def test_find_format(self):

185

130

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

186

131

        # create a branch with a few known format objects.

192

137

            format.initialize(dir)

193

138

            t = transport.get_transport(url)

194

139

            found_format = workingtree.WorkingTreeFormat.find_format(dir)

195

 

            self.assertIsInstance(found_format, format.__class__)

196

 

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

 

140

            self.failUnless(isinstance(found_format, format.__class__))

 

141

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

197

142

 

198

143

    def test_find_format_no_tree(self):

199

144

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

219

164

        # make a branch

220

165

        format.initialize(dir)

221

166

        # register a format for it.

222

 

        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

223

 

            workingtree.WorkingTreeFormat.register_format, format)

224

 

        self.assertTrue(format in 

225

 

            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

226

 

                workingtree.WorkingTreeFormat.get_formats))

 

167

        workingtree.WorkingTreeFormat.register_format(format)

227

168

        # which branch.Open will refuse (not supported)

228

169

        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')

229

170

        # but open_downlevel will work

230

171

        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))

231

172

        # unregister the format

232

 

        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

233

 

            workingtree.WorkingTreeFormat.unregister_format, format)

234

 

        self.assertFalse(format in

235

 

            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

236

 

                workingtree.WorkingTreeFormat.get_formats))

237

 

 

238

 

 

239

 

class TestWorkingTreeFormatRegistry(TestCase):

240

 

 

241

 

    def setUp(self):

242

 

        super(TestWorkingTreeFormatRegistry, self).setUp()

243

 

        self.registry = workingtree.WorkingTreeFormatRegistry()

244

 

 

245

 

    def test_register_unregister_format(self):

246

 

        format = SampleTreeFormat()

247

 

        self.registry.register(format)

248

 

        self.assertEquals(format, self.registry.get("Sample tree format."))

249

 

        self.registry.remove(format)

250

 

        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")

251

 

 

252

 

    def test_get_all(self):

253

 

        format = SampleTreeFormat()

254

 

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

255

 

        self.registry.register(format)

256

 

        self.assertEquals([format], self.registry._get_all())

257

 

 

258

 

    def test_register_extra(self):

259

 

        format = SampleExtraTreeFormat()

260

 

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

261

 

        self.registry.register_extra(format)

262

 

        self.assertEquals([format], self.registry._get_all())

263

 

 

264

 

    def test_register_extra_lazy(self):

265

 

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

266

 

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

267

 

            "SampleExtraTreeFormat")

268

 

        formats = self.registry._get_all()

269

 

        self.assertEquals(1, len(formats))

270

 

        self.assertIsInstance(formats[0], SampleExtraTreeFormat)

 

173

        workingtree.WorkingTreeFormat.unregister_format(format)

271

174

 

272

175

 

273

176

class TestWorkingTreeFormat3(TestCaseWithTransport):

277

180

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

278

181

        control.create_repository()

279

182

        control.create_branch()

280

 

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

 

183

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

281

184

        # we want:

282

185

        # format 'Bazaar-NG Working Tree format 3'

283

186

        # inventory = blank inventory

311

214

        repo = dir.create_repository()

312

215

        branch = dir.create_branch()

313

216

        try:

314

 

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

 

217

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

315

218

        except errors.NotLocalUrl:

316

219

            raise TestSkipped('Not a local URL')

317

220

        self.assertIsDirectory('.bzr', t)

328

231

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

329

232

        control.create_repository()

330

233

        control.create_branch()

331

 

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

 

234

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

332

235

        tree._transport.delete("pending-merges")

333

236

        self.assertEqual([], tree.get_parent_ids())

334

237

 

335

238

 

 

239

class TestFormat2WorkingTree(TestCaseWithTransport):

 

240

    """Tests that are specific to format 2 trees."""

 

241

 

 

242

    def create_format2_tree(self, url):

 

243

        return self.make_branch_and_tree(

 

244

            url, format=bzrdir.BzrDirFormat6())

 

245

 

 

246

    def test_conflicts(self):

 

247

        # test backwards compatability

 

248

        tree = self.create_format2_tree('.')

 

249

        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,

 

250

                          None)

 

251

        file('lala.BASE', 'wb').write('labase')

 

252

        expected = conflicts.ContentsConflict('lala')

 

253

        self.assertEqual(list(tree.conflicts()), [expected])

 

254

        file('lala', 'wb').write('la')

 

255

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

 

256

        expected = conflicts.ContentsConflict('lala', file_id='lala-id')

 

257

        self.assertEqual(list(tree.conflicts()), [expected])

 

258

        file('lala.THIS', 'wb').write('lathis')

 

259

        file('lala.OTHER', 'wb').write('laother')

 

260

        # When "text conflict"s happen, stem, THIS and OTHER are text

 

261

        expected = conflicts.TextConflict('lala', file_id='lala-id')

 

262

        self.assertEqual(list(tree.conflicts()), [expected])

 

263

        os.unlink('lala.OTHER')

 

264

        os.mkdir('lala.OTHER')

 

265

        expected = conflicts.ContentsConflict('lala', file_id='lala-id')

 

266

        self.assertEqual(list(tree.conflicts()), [expected])

 

267

 

 

268

 

336

269

class InstrumentedTree(object):

337

270

    """A instrumented tree to check the needs_tree_write_lock decorator."""

338

271

 

409

342

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

410

343

        other.commit('Case switch')

411

344

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

412

 

        self.assertPathExists('this/hello')

 

345

        self.failUnlessExists('this/hello')

413

346

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

414

347

        this.commit('Add World')

415

348

        this.merge_from_branch(other.branch)

436

369

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

437

370

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

438

371

                         resolved)

439

 

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

 

372

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

440

373

 

441

374

    def test_auto_resolve_dir(self):

442

375

        tree = self.make_branch_and_tree('tree')

• Older »

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