~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

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

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

Show diffs side-by-side

added

removed

bzrlib/tests/test_workingtree.py

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('.')

168

146

class TestWorkingTreeFormat(TestCaseWithTransport):

169

147

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

170

148

 

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

149

    def test_find_format(self):

185

150

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

186

151

        # create a branch with a few known format objects.

192

157

            format.initialize(dir)

193

158

            t = transport.get_transport(url)

194

159

            found_format = workingtree.WorkingTreeFormat.find_format(dir)

195

 

            self.assertIsInstance(found_format, format.__class__)

196

 

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

 

160

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

 

161

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

197

162

 

198

163

    def test_find_format_no_tree(self):

199

164

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

219

184

        # make a branch

220

185

        format.initialize(dir)

221

186

        # 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))

 

187

        workingtree.WorkingTreeFormat.register_format(format)

 

188

        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())

227

189

        # which branch.Open will refuse (not supported)

228

190

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

229

191

        # but open_downlevel will work

230

192

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

231

193

        # 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):

 

194

        workingtree.WorkingTreeFormat.unregister_format(format)

 

195

        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())

 

196

 

 

197

    def test_register_unregister_extra_format(self):

259

198

        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)

 

199

        workingtree.WorkingTreeFormat.register_extra_format(format)

 

200

        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())

 

201

        workingtree.WorkingTreeFormat.unregister_extra_format(format)

 

202

        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())

271

203

 

272

204

 

273

205

class TestWorkingTreeFormat3(TestCaseWithTransport):

277

209

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

278

210

        control.create_repository()

279

211

        control.create_branch()

280

 

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

 

212

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

281

213

        # we want:

282

214

        # format 'Bazaar-NG Working Tree format 3'

283

215

        # inventory = blank inventory

311

243

        repo = dir.create_repository()

312

244

        branch = dir.create_branch()

313

245

        try:

314

 

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

 

246

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

315

247

        except errors.NotLocalUrl:

316

248

            raise TestSkipped('Not a local URL')

317

249

        self.assertIsDirectory('.bzr', t)

328

260

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

329

261

        control.create_repository()

330

262

        control.create_branch()

331

 

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

 

263

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

332

264

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

333

265

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

334

266

 

335

267

 

 

268

class TestFormat2WorkingTree(TestCaseWithTransport):

 

269

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

 

270

 

 

271

    def create_format2_tree(self, url):

 

272

        return self.make_branch_and_tree(

 

273

            url, format=bzrdir.BzrDirFormat6())

 

274

 

 

275

    def test_conflicts(self):

 

276

        # test backwards compatability

 

277

        tree = self.create_format2_tree('.')

 

278

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

 

279

                          None)

 

280

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

 

281

        expected = conflicts.ContentsConflict('lala')

 

282

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

 

283

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

 

284

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

 

285

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

 

286

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

 

287

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

 

288

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

 

289

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

 

290

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

 

291

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

 

292

        os.unlink('lala.OTHER')

 

293

        os.mkdir('lala.OTHER')

 

294

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

 

295

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

 

296

 

 

297

 

336

298

class InstrumentedTree(object):

337

299

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

338

300

 

409

371

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

410

372

        other.commit('Case switch')

411

373

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

412

 

        self.assertPathExists('this/hello')

 

374

        self.failUnlessExists('this/hello')

413

375

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

414

376

        this.commit('Add World')

415

377

        this.merge_from_branch(other.branch)

436

398

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

437

399

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

438

400

                         resolved)

439

 

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

 

401

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

440

402

 

441

403

    def test_auto_resolve_dir(self):

442

404

        tree = self.make_branch_and_tree('tree')

• Older »

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