← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_repository.py

  • Committer: Martin Pool
  • Date: 2006-02-22 04:29:54 UTC
  • mfrom: (1566 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1569.
  • Revision ID: mbp@sourcefrog.net-20060222042954-60333f08dd56a646
[merge] from bzr.dev before integration
Fix undefined ordering in sign_my_revisions breaking tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_repository.py
1
 
# Copyright (C) 2006 Canonical Ltd
2
 
#
 
1
# (C) 2006 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22
22
also see this file.
23
23
"""
24
24
 
25
 
from stat import S_ISDIR
 
25
from stat import *
26
26
from StringIO import StringIO
27
27
 
28
 
import bzrlib
29
28
import bzrlib.bzrdir as bzrdir
30
29
import bzrlib.errors as errors
31
30
from bzrlib.errors import (NotBranchError,
44
43
 
45
44
    def test_get_set_default_format(self):
46
45
        old_format = repository.RepositoryFormat.get_default_format()
47
 
        self.assertTrue(isinstance(old_format, repository.RepositoryFormatKnit1))
 
46
        # default is None - we cannot create a Repository independently yet
 
47
        self.assertTrue(isinstance(old_format, repository.RepositoryFormat7))
48
48
        repository.RepositoryFormat.set_default_format(SampleRepositoryFormat())
49
49
        # creating a repository should now create an instrumented dir.
50
50
        try:
51
51
            # the default branch format is used by the meta dir format
52
52
            # which is not the default bzrdir format at this point
53
 
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:///')
 
53
            dir = bzrdir.BzrDirMetaFormat1().initialize('memory:/')
54
54
            result = dir.create_repository()
55
55
            self.assertEqual(result, 'A bzr repository dir')
56
56
        finally:
156
156
        t = control.get_repository_transport(None)
157
157
        self.assertEqualDiff('Bazaar-NG Repository format 7',
158
158
                             t.get('format').read())
159
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
160
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
161
 
        self.assertEqualDiff('# bzr weave file v5\n'
162
 
                             'w\n'
163
 
                             'W\n',
164
 
                             t.get('inventory.weave').read())
165
 
 
166
 
    def test_shared_disk_layout(self):
167
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
168
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
169
 
        # we want:
170
 
        # format 'Bazaar-NG Repository format 7'
171
 
        # inventory.weave == empty_weave
172
 
        # empty revision-store directory
173
 
        # empty weaves directory
174
 
        # a 'shared-storage' marker file.
175
 
        # lock is not present when unlocked
176
 
        t = control.get_repository_transport(None)
177
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
178
 
                             t.get('format').read())
179
 
        self.assertEqualDiff('', t.get('shared-storage').read())
180
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
181
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
182
 
        self.assertEqualDiff('# bzr weave file v5\n'
183
 
                             'w\n'
184
 
                             'W\n',
185
 
                             t.get('inventory.weave').read())
186
 
        self.assertFalse(t.has('branch-lock'))
187
 
 
188
 
    def test_creates_lockdir(self):
189
 
        """Make sure it appears to be controlled by a LockDir existence"""
190
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
191
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
192
 
        t = control.get_repository_transport(None)
193
 
        # TODO: Should check there is a 'lock' toplevel directory, 
194
 
        # regardless of contents
195
 
        self.assertFalse(t.has('lock/held/info'))
196
 
        repo.lock_write()
197
 
        try:
198
 
            self.assertTrue(t.has('lock/held/info'))
199
 
        finally:
200
 
            # unlock so we don't get a warning about failing to do so
201
 
            repo.unlock()
202
 
 
203
 
    def test_uses_lockdir(self):
204
 
        """repo format 7 actually locks on lockdir"""
205
 
        base_url = self.get_url()
206
 
        control = bzrdir.BzrDirMetaFormat1().initialize(base_url)
207
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
208
 
        t = control.get_repository_transport(None)
209
 
        repo.lock_write()
210
 
        repo.unlock()
211
 
        del repo
212
 
        # make sure the same lock is created by opening it
213
 
        repo = repository.Repository.open(base_url)
214
 
        repo.lock_write()
215
 
        self.assertTrue(t.has('lock/held/info'))
216
 
        repo.unlock()
217
 
        self.assertFalse(t.has('lock/held/info'))
218
 
 
219
 
    def test_shared_no_tree_disk_layout(self):
220
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
221
 
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
222
 
        repo.set_make_working_trees(False)
223
 
        # we want:
224
 
        # format 'Bazaar-NG Repository format 7'
225
 
        # lock ''
226
 
        # inventory.weave == empty_weave
227
 
        # empty revision-store directory
228
 
        # empty weaves directory
229
 
        # a 'shared-storage' marker file.
230
 
        t = control.get_repository_transport(None)
231
 
        self.assertEqualDiff('Bazaar-NG Repository format 7',
232
 
                             t.get('format').read())
233
 
        ## self.assertEqualDiff('', t.get('lock').read())
234
 
        self.assertEqualDiff('', t.get('shared-storage').read())
235
 
        self.assertEqualDiff('', t.get('no-working-trees').read())
236
 
        repo.set_make_working_trees(True)
237
 
        self.assertFalse(t.has('no-working-trees'))
238
 
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
239
 
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
240
 
        self.assertEqualDiff('# bzr weave file v5\n'
241
 
                             'w\n'
242
 
                             'W\n',
243
 
                             t.get('inventory.weave').read())
244
 
 
245
 
 
246
 
class TestFormatKnit1(TestCaseWithTransport):
247
 
    
248
 
    def test_disk_layout(self):
249
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
250
 
        repo = repository.RepositoryFormatKnit1().initialize(control)
251
 
        # in case of side effects of locking.
252
 
        repo.lock_write()
253
 
        repo.unlock()
254
 
        # we want:
255
 
        # format 'Bazaar-NG Knit Repository Format 1'
256
 
        # lock: is a directory
257
 
        # inventory.weave == empty_weave
258
 
        # empty revision-store directory
259
 
        # empty weaves directory
260
 
        t = control.get_repository_transport(None)
261
 
        self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
262
 
                             t.get('format').read())
263
 
        # XXX: no locks left when unlocked at the moment
264
 
        # self.assertEqualDiff('', t.get('lock').read())
265
 
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
266
 
        self.check_knits(t)
267
 
 
268
 
    def assertHasKnit(self, t, knit_name):
269
 
        """Assert that knit_name exists on t."""
270
 
        self.assertEqualDiff('# bzr knit index 8\n',
271
 
                             t.get(knit_name + '.kndx').read())
272
 
        # no default content
273
 
        self.assertTrue(t.has(knit_name + '.knit'))
274
 
 
275
 
    def check_knits(self, t):
276
 
        """check knit content for a repository."""
277
 
        self.assertHasKnit(t, 'inventory')
278
 
        self.assertHasKnit(t, 'revisions')
279
 
        self.assertHasKnit(t, 'signatures')
280
 
 
281
 
    def test_shared_disk_layout(self):
282
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
283
 
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
284
 
        # we want:
285
 
        # format 'Bazaar-NG Knit Repository Format 1'
286
 
        # lock: is a directory
287
 
        # inventory.weave == empty_weave
288
 
        # empty revision-store directory
289
 
        # empty weaves directory
290
 
        # a 'shared-storage' marker file.
291
 
        t = control.get_repository_transport(None)
292
 
        self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
293
 
                             t.get('format').read())
294
 
        # XXX: no locks left when unlocked at the moment
295
 
        # self.assertEqualDiff('', t.get('lock').read())
296
 
        self.assertEqualDiff('', t.get('shared-storage').read())
297
 
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
298
 
        self.check_knits(t)
299
 
 
300
 
    def test_shared_no_tree_disk_layout(self):
301
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
302
 
        repo = repository.RepositoryFormatKnit1().initialize(control, shared=True)
303
 
        repo.set_make_working_trees(False)
304
 
        # we want:
305
 
        # format 'Bazaar-NG Knit Repository Format 1'
306
 
        # lock ''
307
 
        # inventory.weave == empty_weave
308
 
        # empty revision-store directory
309
 
        # empty weaves directory
310
 
        # a 'shared-storage' marker file.
311
 
        t = control.get_repository_transport(None)
312
 
        self.assertEqualDiff('Bazaar-NG Knit Repository Format 1',
313
 
                             t.get('format').read())
314
 
        # XXX: no locks left when unlocked at the moment
315
 
        # self.assertEqualDiff('', t.get('lock').read())
316
 
        self.assertEqualDiff('', t.get('shared-storage').read())
317
 
        self.assertEqualDiff('', t.get('no-working-trees').read())
318
 
        repo.set_make_working_trees(True)
319
 
        self.assertFalse(t.has('no-working-trees'))
320
 
        self.assertTrue(S_ISDIR(t.stat('knits').st_mode))
321
 
        self.check_knits(t)
 
159
        self.assertEqualDiff('', t.get('lock').read())
 
160
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
 
161
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
 
162
        self.assertEqualDiff('# bzr weave file v5\n'
 
163
                             'w\n'
 
164
                             'W\n',
 
165
                             t.get('inventory.weave').read())
 
166
 
 
167
    def test_shared_disk_layout(self):
 
168
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
169
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
170
        # we want:
 
171
        # format 'Bazaar-NG Repository format 7'
 
172
        # lock ''
 
173
        # inventory.weave == empty_weave
 
174
        # empty revision-store directory
 
175
        # empty weaves directory
 
176
        # a 'shared-storage' marker file.
 
177
        t = control.get_repository_transport(None)
 
178
        self.assertEqualDiff('Bazaar-NG Repository format 7',
 
179
                             t.get('format').read())
 
180
        self.assertEqualDiff('', t.get('lock').read())
 
181
        self.assertEqualDiff('', t.get('shared-storage').read())
 
182
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
 
183
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
 
184
        self.assertEqualDiff('# bzr weave file v5\n'
 
185
                             'w\n'
 
186
                             'W\n',
 
187
                             t.get('inventory.weave').read())
 
188
 
 
189
    def test_shared_no_tree_disk_layout(self):
 
190
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
191
        repo = repository.RepositoryFormat7().initialize(control, shared=True)
 
192
        repo.set_make_working_trees(False)
 
193
        # we want:
 
194
        # format 'Bazaar-NG Repository format 7'
 
195
        # lock ''
 
196
        # inventory.weave == empty_weave
 
197
        # empty revision-store directory
 
198
        # empty weaves directory
 
199
        # a 'shared-storage' marker file.
 
200
        t = control.get_repository_transport(None)
 
201
        self.assertEqualDiff('Bazaar-NG Repository format 7',
 
202
                             t.get('format').read())
 
203
        self.assertEqualDiff('', t.get('lock').read())
 
204
        self.assertEqualDiff('', t.get('shared-storage').read())
 
205
        self.assertEqualDiff('', t.get('no-working-trees').read())
 
206
        repo.set_make_working_trees(True)
 
207
        self.assertFalse(t.has('no-working-trees'))
 
208
        self.assertTrue(S_ISDIR(t.stat('revision-store').st_mode))
 
209
        self.assertTrue(S_ISDIR(t.stat('weaves').st_mode))
 
210
        self.assertEqualDiff('# bzr weave file v5\n'
 
211
                             'w\n'
 
212
                             'W\n',
 
213
                             t.get('inventory.weave').read())
322
214
 
323
215
 
324
216
class InterString(repository.InterRepository):
390
282
        formats = [repository.RepositoryFormat5(),
391
283
                   repository.RepositoryFormat6(),
392
284
                   repository.RepositoryFormat7()]
393
 
        incompatible_formats = [repository.RepositoryFormat4(),
394
 
                                repository.RepositoryFormatKnit1(),
395
 
                                ]
396
285
        repo_a = self.make_repository('a')
397
286
        repo_b = self.make_repository('b')
 
287
        # force incompatible left then right
 
288
        repo_a._format = repository.RepositoryFormat4()
 
289
        repo_b._format = formats[0]
398
290
        is_compatible = repository.InterWeaveRepo.is_compatible
399
 
        for source in incompatible_formats:
400
 
            # force incompatible left then right
401
 
            repo_a._format = source
402
 
            repo_b._format = formats[0]
403
 
            self.assertFalse(is_compatible(repo_a, repo_b))
404
 
            self.assertFalse(is_compatible(repo_b, repo_a))
 
291
        self.assertFalse(is_compatible(repo_a, repo_b))
 
292
        self.assertFalse(is_compatible(repo_b, repo_a))
405
293
        for source in formats:
406
294
            repo_a._format = source
407
295
            for target in formats:
410
298
        self.assertEqual(repository.InterWeaveRepo,
411
299
                         repository.InterRepository.get(repo_a,
412
300
                                                        repo_b).__class__)
413
 
 
414
 
 
415
 
class TestRepositoryConverter(TestCaseWithTransport):
416
 
 
417
 
    def test_convert_empty(self):
418
 
        t = get_transport(self.get_url('.'))
419
 
        t.mkdir('repository')
420
 
        repo_dir = bzrdir.BzrDirMetaFormat1().initialize('repository')
421
 
        repo = repository.RepositoryFormat7().initialize(repo_dir)
422
 
        target_format = repository.RepositoryFormatKnit1()
423
 
        converter = repository.CopyConverter(target_format)
424
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
425
 
        try:
426
 
            converter.convert(repo, pb)
427
 
        finally:
428
 
            pb.finished()
429
 
        repo = repo_dir.open_repository()
430
 
        self.assertTrue(isinstance(target_format, repo._format.__class__))
431
 
 
432
 
 
433
 
class TestMisc(TestCase):
434
 
    
435
 
    def test_unescape_xml(self):
436
 
        """We get some kind of error when malformed entities are passed"""
437
 
        self.assertRaises(KeyError, repository._unescape_xml, 'foo&bar;')