← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-14 00:01:32 UTC
  • mfrom: (4957.1.1 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100114000132-3p3rabnonjw3gzqb
(jam) Merge bzr.stable, bringing in bug fixes #175839, #504390

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart.py
29
29
import tarfile
30
30
 
31
31
from bzrlib import (
 
32
    bencode,
32
33
    bzrdir,
33
34
    errors,
34
35
    pack,
35
36
    smart,
36
37
    tests,
37
38
    urlutils,
 
39
    versionedfile,
38
40
    )
39
41
from bzrlib.branch import Branch, BranchReferenceFormat
40
42
import bzrlib.smart.branch
41
43
import bzrlib.smart.bzrdir, bzrlib.smart.bzrdir as smart_dir
42
44
import bzrlib.smart.packrepository
43
45
import bzrlib.smart.repository
 
46
import bzrlib.smart.vfs
44
47
from bzrlib.smart.request import (
45
48
    FailedSmartServerResponse,
46
49
    SmartServerRequest,
50
53
from bzrlib.tests import (
51
54
    split_suite_by_re,
52
55
    )
53
 
from bzrlib.transport import chroot, get_transport
54
 
from bzrlib.util import bencode
 
56
from bzrlib.transport import chroot, get_transport, local, memory
55
57
 
56
58
 
57
59
def load_tests(standard_tests, module, loader):
80
82
class TestCaseWithChrootedTransport(tests.TestCaseWithTransport):
81
83
 
82
84
    def setUp(self):
 
85
        self.vfs_transport_factory = memory.MemoryServer
83
86
        tests.TestCaseWithTransport.setUp(self)
84
87
        self._chroot_server = None
85
88
 
87
90
        if self._chroot_server is None:
88
91
            backing_transport = tests.TestCaseWithTransport.get_transport(self)
89
92
            self._chroot_server = chroot.ChrootServer(backing_transport)
90
 
            self._chroot_server.setUp()
91
 
            self.addCleanup(self._chroot_server.tearDown)
 
93
            self.start_server(self._chroot_server)
92
94
        t = get_transport(self._chroot_server.get_url())
93
95
        if relpath is not None:
94
96
            t = t.clone(relpath)
95
97
        return t
96
98
 
97
99
 
98
 
class TestCaseWithSmartMedium(tests.TestCaseWithTransport):
 
100
class TestCaseWithSmartMedium(tests.TestCaseWithMemoryTransport):
99
101
 
100
102
    def setUp(self):
101
103
        super(TestCaseWithSmartMedium, self).setUp()
113
115
        return self.get_transport().get_smart_medium()
114
116
 
115
117
 
 
118
class TestByteStreamToStream(tests.TestCase):
 
119
 
 
120
    def test_repeated_substreams_same_kind_are_one_stream(self):
 
121
        # Make a stream - an iterable of bytestrings.
 
122
        stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
 
123
            None, 'foo')]),('text', [
 
124
            versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
 
125
        fmt = bzrdir.format_registry.get('pack-0.92')().repository_format
 
126
        bytes = smart.repository._stream_to_byte_stream(stream, fmt)
 
127
        streams = []
 
128
        # Iterate the resulting iterable; checking that we get only one stream
 
129
        # out.
 
130
        fmt, stream = smart.repository._byte_stream_to_stream(bytes)
 
131
        for kind, substream in stream:
 
132
            streams.append((kind, list(substream)))
 
133
        self.assertLength(1, streams)
 
134
        self.assertLength(2, streams[0][1])
 
135
 
 
136
 
116
137
class TestSmartServerResponse(tests.TestCase):
117
138
 
118
139
    def test__eq__(self):
150
171
        self.assertRaises(
151
172
            errors.PathNotChild, request.translate_client_path, 'bar/')
152
173
        self.assertEqual('./baz', request.translate_client_path('foo/baz'))
 
174
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
 
175
        self.assertEqual('./' + urlutils.escape(e_acute),
 
176
                         request.translate_client_path('foo/' + e_acute))
 
177
 
 
178
    def test_translate_client_path_vfs(self):
 
179
        """VfsRequests receive escaped paths rather than raw UTF-8."""
 
180
        transport = self.get_transport()
 
181
        request = smart.vfs.VfsRequest(transport, 'foo/')
 
182
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
 
183
        escaped = urlutils.escape('foo/' + e_acute)
 
184
        self.assertEqual('./' + urlutils.escape(e_acute),
 
185
                         request.translate_client_path(escaped))
153
186
 
154
187
    def test_transport_from_client_path(self):
155
188
        transport = self.get_transport()
202
235
        self.make_bzrdir('.')
203
236
        request_class = bzrlib.smart.bzrdir.SmartServerRequestCreateRepository
204
237
        request = request_class(backing)
205
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
238
        reference_bzrdir_format = bzrdir.format_registry.get('pack-0.92')()
206
239
        reference_format = reference_bzrdir_format.repository_format
207
240
        network_name = reference_format.network_name()
208
241
        expected = SuccessfulSmartServerResponse(
247
280
            subtrees = 'yes'
248
281
        else:
249
282
            subtrees = 'no'
 
283
        if repo._format.supports_external_lookups:
 
284
            external = 'yes'
 
285
        else:
 
286
            external = 'no'
250
287
        if (smart.bzrdir.SmartServerRequestFindRepositoryV3 ==
251
288
            self._request_class):
252
289
            return SuccessfulSmartServerResponse(
253
 
                ('ok', '', rich_root, subtrees, 'no',
 
290
                ('ok', '', rich_root, subtrees, external,
254
291
                 repo._format.network_name()))
255
292
        elif (smart.bzrdir.SmartServerRequestFindRepositoryV2 ==
256
293
            self._request_class):
257
294
            # All tests so far are on formats, and for non-external
258
295
            # repositories.
259
296
            return SuccessfulSmartServerResponse(
260
 
                ('ok', '', rich_root, subtrees, 'no'))
 
297
                ('ok', '', rich_root, subtrees, external))
261
298
        else:
262
299
            return SuccessfulSmartServerResponse(('ok', '', rich_root, subtrees))
263
300
 
350
387
            request.execute, 'subdir')
351
388
 
352
389
 
 
390
class TestSmartServerRequestBzrDirInitializeEx(tests.TestCaseWithMemoryTransport):
 
391
    """Basic tests for BzrDir.initialize_ex_1.16 in the smart server.
 
392
 
 
393
    The main unit tests in test_bzrdir exercise the API comprehensively.
 
394
    """
 
395
 
 
396
    def test_empty_dir(self):
 
397
        """Initializing an empty dir should succeed and do it."""
 
398
        backing = self.get_transport()
 
399
        name = self.make_bzrdir('reference')._format.network_name()
 
400
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
401
        self.assertEqual(SmartServerResponse(('', '', '', '', '', '', name,
 
402
            'False', '', '', '')),
 
403
            request.execute(name, '', 'True', 'False', 'False', '', '', '', '',
 
404
            'False'))
 
405
        made_dir = bzrdir.BzrDir.open_from_transport(backing)
 
406
        # no branch, tree or repository is expected with the current
 
407
        # default format.
 
408
        self.assertRaises(errors.NoWorkingTree, made_dir.open_workingtree)
 
409
        self.assertRaises(errors.NotBranchError, made_dir.open_branch)
 
410
        self.assertRaises(errors.NoRepositoryPresent, made_dir.open_repository)
 
411
 
 
412
    def test_missing_dir(self):
 
413
        """Initializing a missing directory should fail like the bzrdir api."""
 
414
        backing = self.get_transport()
 
415
        name = self.make_bzrdir('reference')._format.network_name()
 
416
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
417
        self.assertRaises(errors.NoSuchFile, request.execute, name,
 
418
            'subdir/dir', 'False', 'False', 'False', '', '', '', '', 'False')
 
419
 
 
420
    def test_initialized_dir(self):
 
421
        """Initializing an extant directory should fail like the bzrdir api."""
 
422
        backing = self.get_transport()
 
423
        name = self.make_bzrdir('reference')._format.network_name()
 
424
        request = smart.bzrdir.SmartServerRequestBzrDirInitializeEx(backing)
 
425
        self.make_bzrdir('subdir')
 
426
        self.assertRaises(errors.FileExists, request.execute, name, 'subdir',
 
427
            'False', 'False', 'False', '', '', '', '', 'False')
 
428
 
 
429
 
 
430
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
 
431
    
 
432
    def test_no_directory(self):
 
433
        backing = self.get_transport()
 
434
        request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing)
 
435
        self.assertEqual(SmartServerResponse(('no', )),
 
436
            request.execute('does-not-exist'))
 
437
 
 
438
    def test_empty_directory(self):
 
439
        backing = self.get_transport()
 
440
        backing.mkdir('empty')
 
441
        request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing)
 
442
        self.assertEqual(SmartServerResponse(('no', )),
 
443
            request.execute('empty'))
 
444
 
 
445
    def test_outside_root_client_path(self):
 
446
        backing = self.get_transport()
 
447
        request = smart.bzrdir.SmartServerRequestOpenBzrDir(backing,
 
448
            root_client_path='root')
 
449
        self.assertEqual(SmartServerResponse(('no', )),
 
450
            request.execute('not-root'))
 
451
 
 
452
    
 
453
class TestSmartServerRequestOpenBzrDir_2_1(tests.TestCaseWithMemoryTransport):
 
454
    
 
455
    def test_no_directory(self):
 
456
        backing = self.get_transport()
 
457
        request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
 
458
        self.assertEqual(SmartServerResponse(('no', )),
 
459
            request.execute('does-not-exist'))
 
460
 
 
461
    def test_empty_directory(self):
 
462
        backing = self.get_transport()
 
463
        backing.mkdir('empty')
 
464
        request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
 
465
        self.assertEqual(SmartServerResponse(('no', )),
 
466
            request.execute('empty'))
 
467
 
 
468
    def test_present_without_workingtree(self):
 
469
        backing = self.get_transport()
 
470
        request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
 
471
        self.make_bzrdir('.')
 
472
        self.assertEqual(SmartServerResponse(('yes', 'no')),
 
473
            request.execute(''))
 
474
 
 
475
    def test_outside_root_client_path(self):
 
476
        backing = self.get_transport()
 
477
        request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing,
 
478
            root_client_path='root')
 
479
        self.assertEqual(SmartServerResponse(('no',)),
 
480
            request.execute('not-root'))
 
481
 
 
482
    
 
483
class TestSmartServerRequestOpenBzrDir_2_1_disk(TestCaseWithChrootedTransport):
 
484
 
 
485
    def test_present_with_workingtree(self):
 
486
        self.vfs_transport_factory = local.LocalURLServer
 
487
        backing = self.get_transport()
 
488
        request = smart.bzrdir.SmartServerRequestOpenBzrDir_2_1(backing)
 
489
        bd = self.make_bzrdir('.')
 
490
        bd.create_repository()
 
491
        bd.create_branch()
 
492
        bd.create_workingtree()
 
493
        self.assertEqual(SmartServerResponse(('yes', 'yes')),
 
494
            request.execute(''))
 
495
 
 
496
 
353
497
class TestSmartServerRequestOpenBranch(TestCaseWithChrootedTransport):
354
498
 
355
499
    def test_no_branch(self):
370
514
 
371
515
    def test_branch_reference(self):
372
516
        """When there is a branch reference, the reference URL is returned."""
 
517
        self.vfs_transport_factory = local.LocalURLServer
373
518
        backing = self.get_transport()
374
519
        request = smart.bzrdir.SmartServerRequestOpenBranch(backing)
375
520
        branch = self.make_branch('branch')
400
545
 
401
546
    def test_branch_reference(self):
402
547
        """When there is a branch reference, the reference URL is returned."""
 
548
        self.vfs_transport_factory = local.LocalURLServer
403
549
        backing = self.get_transport()
404
550
        request = smart.bzrdir.SmartServerRequestOpenBranchV2(backing)
405
551
        branch = self.make_branch('branch')
412
558
    def test_stacked_branch(self):
413
559
        """Opening a stacked branch does not open the stacked-on branch."""
414
560
        trunk = self.make_branch('trunk')
415
 
        feature = self.make_branch('feature', format='1.9')
 
561
        feature = self.make_branch('feature')
416
562
        feature.set_stacked_on_url(trunk.base)
417
563
        opened_branches = []
418
564
        Branch.hooks.install_named_hook('open', opened_branches.append, None)
546
692
            '')
547
693
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
548
694
        self.assertEqual('bar', config.get_option('foo'))
 
695
        # Cleanup
 
696
        branch.unlock()
549
697
 
550
698
    def test_value_name_section(self):
551
699
        branch = self.make_branch('.')
557
705
            'gam')
558
706
        self.assertEqual(SuccessfulSmartServerResponse(()), result)
559
707
        self.assertEqual('bar', config.get_option('foo', 'gam'))
 
708
        # Cleanup
 
709
        branch.unlock()
 
710
 
 
711
 
 
712
class TestSmartServerBranchRequestSetTagsBytes(TestLockedBranch):
 
713
    # Only called when the branch format and tags match [yay factory
 
714
    # methods] so only need to test straight forward cases.
 
715
 
 
716
    def test_set_bytes(self):
 
717
        base_branch = self.make_branch('base')
 
718
        tag_bytes = base_branch._get_tags_bytes()
 
719
        # get_lock_tokens takes out a lock.
 
720
        branch_token, repo_token = self.get_lock_tokens(base_branch)
 
721
        request = smart.branch.SmartServerBranchSetTagsBytes(
 
722
            self.get_transport())
 
723
        response = request.execute('base', branch_token, repo_token)
 
724
        self.assertEqual(None, response)
 
725
        response = request.do_chunk(tag_bytes)
 
726
        self.assertEqual(None, response)
 
727
        response = request.do_end()
 
728
        self.assertEquals(
 
729
            SuccessfulSmartServerResponse(()), response)
 
730
        base_branch.unlock()
 
731
 
 
732
    def test_lock_failed(self):
 
733
        base_branch = self.make_branch('base')
 
734
        base_branch.lock_write()
 
735
        tag_bytes = base_branch._get_tags_bytes()
 
736
        request = smart.branch.SmartServerBranchSetTagsBytes(
 
737
            self.get_transport())
 
738
        self.assertRaises(errors.TokenMismatch, request.execute,
 
739
            'base', 'wrong token', 'wrong token')
 
740
        # The request handler will keep processing the message parts, so even
 
741
        # if the request fails immediately do_chunk and do_end are still
 
742
        # called.
 
743
        request.do_chunk(tag_bytes)
 
744
        request.do_end()
 
745
        base_branch.unlock()
 
746
 
560
747
 
561
748
 
562
749
class SetLastRevisionTestBase(TestLockedBranch):
828
1015
 
829
1016
 
830
1017
class TestSmartServerBranchRequestGetTagsBytes(tests.TestCaseWithMemoryTransport):
831
 
# Only called when the branch format and tags match [yay factory
832
 
# methods] so only need to test straight forward cases.
 
1018
    # Only called when the branch format and tags match [yay factory
 
1019
    # methods] so only need to test straight forward cases.
833
1020
 
834
1021
    def test_get_bytes(self):
835
1022
        base_branch = self.make_branch('base')
875
1062
        # with a new branch object.
876
1063
        new_branch = repository.bzrdir.open_branch()
877
1064
        self.assertRaises(errors.LockContention, new_branch.lock_write)
 
1065
        # Cleanup
 
1066
        request = smart.branch.SmartServerBranchRequestUnlock(backing)
 
1067
        response = request.execute('', branch_nonce, repository_nonce)
878
1068
 
879
1069
    def test_lock_write_on_locked_branch(self):
880
1070
        backing = self.get_transport()
881
1071
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
882
1072
        branch = self.make_branch('.')
883
 
        branch.lock_write()
 
1073
        branch_token = branch.lock_write()
884
1074
        branch.leave_lock_in_place()
885
1075
        branch.unlock()
886
1076
        response = request.execute('')
887
1077
        self.assertEqual(
888
1078
            SmartServerResponse(('LockContention',)), response)
 
1079
        # Cleanup
 
1080
        branch.lock_write(branch_token)
 
1081
        branch.dont_leave_lock_in_place()
 
1082
        branch.unlock()
889
1083
 
890
1084
    def test_lock_write_with_tokens_on_locked_branch(self):
891
1085
        backing = self.get_transport()
901
1095
                                   branch_token, repo_token)
902
1096
        self.assertEqual(
903
1097
            SmartServerResponse(('ok', branch_token, repo_token)), response)
 
1098
        # Cleanup
 
1099
        branch.repository.lock_write(repo_token)
 
1100
        branch.repository.dont_leave_lock_in_place()
 
1101
        branch.repository.unlock()
 
1102
        branch.lock_write(branch_token)
 
1103
        branch.dont_leave_lock_in_place()
 
1104
        branch.unlock()
904
1105
 
905
1106
    def test_lock_write_with_mismatched_tokens_on_locked_branch(self):
906
1107
        backing = self.get_transport()
916
1117
                                   branch_token+'xxx', repo_token)
917
1118
        self.assertEqual(
918
1119
            SmartServerResponse(('TokenMismatch',)), response)
 
1120
        # Cleanup
 
1121
        branch.repository.lock_write(repo_token)
 
1122
        branch.repository.dont_leave_lock_in_place()
 
1123
        branch.repository.unlock()
 
1124
        branch.lock_write(branch_token)
 
1125
        branch.dont_leave_lock_in_place()
 
1126
        branch.unlock()
919
1127
 
920
1128
    def test_lock_write_on_locked_repo(self):
921
1129
        backing = self.get_transport()
922
1130
        request = smart.branch.SmartServerBranchRequestLockWrite(backing)
923
1131
        branch = self.make_branch('.', format='knit')
924
 
        branch.repository.lock_write()
925
 
        branch.repository.leave_lock_in_place()
926
 
        branch.repository.unlock()
 
1132
        repo = branch.repository
 
1133
        repo_token = repo.lock_write()
 
1134
        repo.leave_lock_in_place()
 
1135
        repo.unlock()
927
1136
        response = request.execute('')
928
1137
        self.assertEqual(
929
1138
            SmartServerResponse(('LockContention',)), response)
 
1139
        # Cleanup
 
1140
        repo.lock_write(repo_token)
 
1141
        repo.dont_leave_lock_in_place()
 
1142
        repo.unlock()
930
1143
 
931
1144
    def test_lock_write_on_readonly_transport(self):
932
1145
        backing = self.get_readonly_transport()
991
1204
            '', 'branch token', repo_token)
992
1205
        self.assertEqual(
993
1206
            SmartServerResponse(('TokenMismatch',)), response)
 
1207
        # Cleanup
 
1208
        branch.repository.lock_write(repo_token)
 
1209
        branch.repository.dont_leave_lock_in_place()
 
1210
        branch.repository.unlock()
994
1211
 
995
1212
 
996
1213
class TestSmartServerRepositoryRequest(tests.TestCaseWithMemoryTransport):
1087
1304
            request.execute('', 'missingrevision'))
1088
1305
 
1089
1306
 
 
1307
class TestSmartServerRepositoryGetRevIdForRevno(tests.TestCaseWithMemoryTransport):
 
1308
 
 
1309
    def test_revno_found(self):
 
1310
        backing = self.get_transport()
 
1311
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1312
        tree = self.make_branch_and_memory_tree('.')
 
1313
        tree.lock_write()
 
1314
        tree.add('')
 
1315
        rev1_id_utf8 = u'\xc8'.encode('utf-8')
 
1316
        rev2_id_utf8 = u'\xc9'.encode('utf-8')
 
1317
        tree.commit('1st commit', rev_id=rev1_id_utf8)
 
1318
        tree.commit('2nd commit', rev_id=rev2_id_utf8)
 
1319
        tree.unlock()
 
1320
 
 
1321
        self.assertEqual(SmartServerResponse(('ok', rev1_id_utf8)),
 
1322
            request.execute('', 1, (2, rev2_id_utf8)))
 
1323
 
 
1324
    def test_known_revid_missing(self):
 
1325
        backing = self.get_transport()
 
1326
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1327
        repo = self.make_repository('.')
 
1328
        self.assertEqual(
 
1329
            FailedSmartServerResponse(('nosuchrevision', 'ghost')),
 
1330
            request.execute('', 1, (2, 'ghost')))
 
1331
 
 
1332
    def test_history_incomplete(self):
 
1333
        backing = self.get_transport()
 
1334
        request = smart.repository.SmartServerRepositoryGetRevIdForRevno(backing)
 
1335
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
 
1336
        parent.lock_write()
 
1337
        parent.add([''], ['TREE_ROOT'])
 
1338
        r1 = parent.commit(message='first commit')
 
1339
        r2 = parent.commit(message='second commit')
 
1340
        parent.unlock()
 
1341
        local = self.make_branch_and_memory_tree('local', format='1.9')
 
1342
        local.branch.pull(parent.branch)
 
1343
        local.set_parent_ids([r2])
 
1344
        r3 = local.commit(message='local commit')
 
1345
        local.branch.create_clone_on_transport(
 
1346
            self.get_transport('stacked'), stacked_on=self.get_url('parent'))
 
1347
        self.assertEqual(
 
1348
            SmartServerResponse(('history-incomplete', 2, r2)),
 
1349
            request.execute('stacked', 1, (3, r3)))
 
1350
 
 
1351
 
1090
1352
class TestSmartServerRepositoryGetStream(tests.TestCaseWithMemoryTransport):
1091
1353
 
1092
1354
    def make_two_commit_repo(self):
1242
1504
        # object.
1243
1505
        new_repo = repository.bzrdir.open_repository()
1244
1506
        self.assertRaises(errors.LockContention, new_repo.lock_write)
 
1507
        # Cleanup
 
1508
        request = smart.repository.SmartServerRepositoryUnlock(backing)
 
1509
        response = request.execute('', nonce)
1245
1510
 
1246
1511
    def test_lock_write_on_locked_repo(self):
1247
1512
        backing = self.get_transport()
1248
1513
        request = smart.repository.SmartServerRepositoryLockWrite(backing)
1249
1514
        repository = self.make_repository('.', format='knit')
1250
 
        repository.lock_write()
 
1515
        repo_token = repository.lock_write()
1251
1516
        repository.leave_lock_in_place()
1252
1517
        repository.unlock()
1253
1518
        response = request.execute('')
1254
1519
        self.assertEqual(
1255
1520
            SmartServerResponse(('LockContention',)), response)
 
1521
        # Cleanup
 
1522
        repository.lock_write(repo_token)
 
1523
        repository.dont_leave_lock_in_place()
 
1524
        repository.unlock()
1256
1525
 
1257
1526
    def test_lock_write_on_readonly_transport(self):
1258
1527
        backing = self.get_readonly_transport()
1434
1703
        self.assertEqual(SmartServerResponse(('ok',)), response)
1435
1704
 
1436
1705
 
 
1706
class TestSmartServerVfsGet(tests.TestCaseWithMemoryTransport):
 
1707
 
 
1708
    def test_unicode_path(self):
 
1709
        """VFS requests expect unicode paths to be escaped."""
 
1710
        filename = u'foo\N{INTERROBANG}'
 
1711
        filename_escaped = urlutils.escape(filename)
 
1712
        backing = self.get_transport()
 
1713
        request = smart.vfs.GetRequest(backing)
 
1714
        backing.put_bytes_non_atomic(filename_escaped, 'contents')
 
1715
        self.assertEqual(SmartServerResponse(('ok', ), 'contents'),
 
1716
            request.execute(filename_escaped))
 
1717
 
 
1718
 
1437
1719
class TestHandlers(tests.TestCase):
1438
1720
    """Tests for the request.request_handlers object."""
1439
1721
 
1479
1761
            smart.bzrdir.SmartServerRequestFindRepositoryV2)
1480
1762
        self.assertHandlerEqual('BzrDirFormat.initialize',
1481
1763
            smart.bzrdir.SmartServerRequestInitializeBzrDir)
 
1764
        self.assertHandlerEqual('BzrDirFormat.initialize_ex_1.16',
 
1765
            smart.bzrdir.SmartServerRequestBzrDirInitializeEx)
1482
1766
        self.assertHandlerEqual('BzrDir.cloning_metadir',
1483
1767
            smart.bzrdir.SmartServerBzrDirRequestCloningMetaDir)
1484
1768
        self.assertHandlerEqual('BzrDir.get_config_file',
1493
1777
            smart.repository.SmartServerRepositoryGatherStats)
1494
1778
        self.assertHandlerEqual('Repository.get_parent_map',
1495
1779
            smart.repository.SmartServerRepositoryGetParentMap)
 
1780
        self.assertHandlerEqual('Repository.get_rev_id_for_revno',
 
1781
            smart.repository.SmartServerRepositoryGetRevIdForRevno)
1496
1782
        self.assertHandlerEqual('Repository.get_revision_graph',
1497
1783
            smart.repository.SmartServerRepositoryGetRevisionGraph)
1498
1784
        self.assertHandlerEqual('Repository.get_stream',