/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_smart.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-12 01:41:38 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181112014138-3b0zyx91cu3wdq3k
More PEP8 fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smart.py
72
72
        ("find_repositoryV3", {
73
73
            "_request_class": smart_dir.SmartServerRequestFindRepositoryV3}),
74
74
        ]
75
 
    to_adapt, result = tests.split_suite_by_re(standard_tests,
76
 
                                               "TestSmartServerRequestFindRepository")
77
 
    v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt,
78
 
                                                "_v2")
 
75
    to_adapt, result = tests.split_suite_by_re(
 
76
        standard_tests, "TestSmartServerRequestFindRepository")
 
77
    v2_only, v1_and_2 = tests.split_suite_by_re(to_adapt, "_v2")
79
78
    tests.multiply_tests(v1_and_2, scenarios, result)
80
79
    # The first scenario is only applicable to v1 protocols, it is deleted
81
80
    # since.
123
122
 
124
123
    def test_repeated_substreams_same_kind_are_one_stream(self):
125
124
        # Make a stream - an iterable of bytestrings.
126
 
        stream = [('text', [versionedfile.FulltextContentFactory((b'k1',), None,
127
 
                                                                 None, b'foo')]), ('text', [
128
 
                                                                     versionedfile.FulltextContentFactory((b'k2',), None, None, b'bar')])]
 
125
        stream = [
 
126
            ('text', [versionedfile.FulltextContentFactory((b'k1',), None,
 
127
             None, b'foo')]),
 
128
            ('text', [versionedfile.FulltextContentFactory((b'k2',), None,
 
129
             None, b'bar')])]
129
130
        fmt = controldir.format_registry.get('pack-0.92')().repository_format
130
131
        bytes = smart_repo._stream_to_byte_stream(stream, fmt)
131
132
        streams = []
178
179
            errors.PathNotChild, request.translate_client_path, b'bar/')
179
180
        self.assertEqual('./baz', request.translate_client_path(b'foo/baz'))
180
181
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'
181
 
        self.assertEqual(u'./' + urlutils.escape(e_acute),
182
 
                         request.translate_client_path(b'foo/' + e_acute.encode('utf-8')))
 
182
        self.assertEqual(
 
183
            u'./' + urlutils.escape(e_acute),
 
184
            request.translate_client_path(b'foo/' + e_acute.encode('utf-8')))
183
185
 
184
186
    def test_translate_client_path_vfs(self):
185
187
        """VfsRequests receive escaped paths rather than raw UTF-8."""
187
189
        request = vfs.VfsRequest(transport, 'foo/')
188
190
        e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'
189
191
        escaped = urlutils.escape(u'foo/' + e_acute)
190
 
        self.assertEqual('./' + urlutils.escape(e_acute),
191
 
                         request.translate_client_path(escaped.encode('ascii')))
 
192
        self.assertEqual(
 
193
            './' + urlutils.escape(e_acute),
 
194
            request.translate_client_path(escaped.encode('ascii')))
192
195
 
193
196
    def test_transport_from_client_path(self):
194
197
        transport = self.get_transport()
220
223
        backing = self.get_transport()
221
224
        referenced_branch = self.make_branch('referenced')
222
225
        dir = self.make_controldir('.')
223
 
        local_result = dir.cloning_metadir()
224
 
        reference = _mod_bzrbranch.BranchReferenceFormat().initialize(
 
226
        dir.cloning_metadir()
 
227
        _mod_bzrbranch.BranchReferenceFormat().initialize(
225
228
            dir, target_branch=referenced_branch)
226
 
        reference_url = _mod_bzrbranch.BranchReferenceFormat().get_reference(dir)
 
229
        _mod_bzrbranch.BranchReferenceFormat().get_reference(dir)
227
230
        # The server shouldn't try to follow the branch reference, so it's fine
228
231
        # if the referenced branch isn't reachable.
229
232
        backing.rename('referenced', 'moved')
233
236
        self.assertEqual(expected, request.execute(b'', b'False'))
234
237
 
235
238
 
236
 
class TestSmartServerBzrDirRequestCloningMetaDir(
 
239
class TestSmartServerBzrDirRequestCheckoutMetaDir(
237
240
        tests.TestCaseWithMemoryTransport):
238
241
    """Tests for BzrDir.checkout_metadir."""
239
242
 
241
244
        backing = self.get_transport()
242
245
        request = smart_dir.SmartServerBzrDirRequestCheckoutMetaDir(
243
246
            backing)
244
 
        branch = self.make_branch('.', format='2a')
 
247
        self.make_branch('.', format='2a')
245
248
        response = request.execute(b'')
246
249
        self.assertEqual(
247
250
            smart_req.SmartServerResponse(
258
261
    def test_destroy_branch_default(self):
259
262
        """The default branch can be removed."""
260
263
        backing = self.get_transport()
261
 
        dir = self.make_branch('.').controldir
 
264
        self.make_branch('.')
262
265
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
263
266
        request = request_class(backing)
264
267
        expected = smart_req.SuccessfulSmartServerResponse((b'ok',))
277
280
    def test_destroy_branch_missing(self):
278
281
        """An error is raised if the branch didn't exist."""
279
282
        backing = self.get_transport()
280
 
        dir = self.make_controldir('.', format="development-colo")
 
283
        self.make_controldir('.', format="development-colo")
281
284
        request_class = smart_dir.SmartServerBzrDirRequestDestroyBranch
282
285
        request = request_class(backing)
283
286
        expected = smart_req.FailedSmartServerResponse((b'nobranch',), None)
291
294
    def test_has_workingtree_yes(self):
292
295
        """A working tree is present."""
293
296
        backing = self.get_transport()
294
 
        dir = self.make_branch_and_tree('.').controldir
 
297
        self.make_branch_and_tree('.')
295
298
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
296
299
        request = request_class(backing)
297
300
        expected = smart_req.SuccessfulSmartServerResponse((b'yes',))
300
303
    def test_has_workingtree_no(self):
301
304
        """A working tree is missing."""
302
305
        backing = self.get_transport()
303
 
        dir = self.make_controldir('.')
 
306
        self.make_controldir('.')
304
307
        request_class = smart_dir.SmartServerBzrDirRequestHasWorkingTree
305
308
        request = request_class(backing)
306
309
        expected = smart_req.SuccessfulSmartServerResponse((b'no',))
314
317
    def test_destroy_repository_default(self):
315
318
        """The repository can be removed."""
316
319
        backing = self.get_transport()
317
 
        dir = self.make_repository('.').controldir
 
320
        self.make_repository('.')
318
321
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
319
322
        request = request_class(backing)
320
323
        expected = smart_req.SuccessfulSmartServerResponse((b'ok',))
323
326
    def test_destroy_repository_missing(self):
324
327
        """An error is raised if the repository didn't exist."""
325
328
        backing = self.get_transport()
326
 
        dir = self.make_controldir('.')
 
329
        self.make_controldir('.')
327
330
        request_class = smart_dir.SmartServerBzrDirRequestDestroyRepository
328
331
        request = request_class(backing)
329
332
        expected = smart_req.FailedSmartServerResponse(
331
334
        self.assertEqual(expected, request.execute(b''))
332
335
 
333
336
 
334
 
class TestSmartServerRequestCreateRepository(tests.TestCaseWithMemoryTransport):
 
337
class TestSmartServerRequestCreateRepository(
 
338
        tests.TestCaseWithMemoryTransport):
335
339
    """Tests for BzrDir.create_repository."""
336
340
 
337
341
    def test_makes_repository(self):
352
356
    """Tests for BzrDir.find_repository."""
353
357
 
354
358
    def test_no_repository(self):
355
 
        """When there is no repository to be found, ('norepository', ) is returned."""
 
359
        """If no repository is found, ('norepository', ) is returned."""
356
360
        backing = self.get_transport()
357
361
        request = self._request_class(backing)
358
362
        self.make_controldir('.')
405
409
                (b'ok', b'', rich_root, subtrees))
406
410
 
407
411
    def test_shared_repository(self):
408
 
        """When there is a shared repository, we get 'ok', 'relpath-to-repo'."""
 
412
        """for a shared repository, we get 'ok', 'relpath-to-repo'."""
409
413
        backing = self.get_transport()
410
414
        request = self._request_class(backing)
411
415
        result = self._make_repository_and_result(shared=True)
459
463
 
460
464
    def test_missing(self):
461
465
        backing = self.get_transport()
462
 
        dir = self.make_controldir('.')
 
466
        self.make_controldir('.')
463
467
        request_class = smart_dir.SmartServerBzrDirRequestConfigFile
464
468
        request = request_class(backing)
465
469
        expected = smart_req.SuccessfulSmartServerResponse((), b'')
483
487
 
484
488
    def test_empty(self):
485
489
        backing = self.get_transport()
486
 
        dir = self.make_controldir('.')
 
490
        self.make_controldir('.')
487
491
        request_class = smart_dir.SmartServerBzrDirRequestGetBranches
488
492
        request = request_class(backing)
489
493
        local_result = bencode.bencode({})
492
496
        self.assertEqual(expected, request.execute(b''))
493
497
 
494
498
 
495
 
class TestSmartServerRequestInitializeBzrDir(tests.TestCaseWithMemoryTransport):
 
499
class TestSmartServerRequestInitializeBzrDir(
 
500
        tests.TestCaseWithMemoryTransport):
496
501
 
497
502
    def test_empty_dir(self):
498
503
        """Initializing an empty dir should succeed and do it."""
538
543
        self.assertEqual(
539
544
            smart_req.SmartServerResponse((b'', b'', b'', b'', b'', b'', name,
540
545
                                           b'False', b'', b'', b'')),
541
 
            request.execute(name, b'', b'True', b'False', b'False', b'', b'', b'', b'',
542
 
                            b'False'))
 
546
            request.execute(name, b'', b'True', b'False', b'False', b'', b'',
 
547
                            b'', b'', b'False'))
543
548
        made_dir = controldir.ControlDir.open_from_transport(backing)
544
549
        # no branch, tree or repository is expected with the current
545
550
        # default format.
553
558
        name = self.make_controldir('reference')._format.network_name()
554
559
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
555
560
        self.assertRaises(errors.NoSuchFile, request.execute, name,
556
 
                          b'subdir/dir', b'False', b'False', b'False', b'', b'', b'', b'', b'False')
 
561
                          b'subdir/dir', b'False', b'False', b'False', b'',
 
562
                          b'', b'', b'', b'False')
557
563
 
558
564
    def test_initialized_dir(self):
559
565
        """Initializing an extant directory should fail like the bzrdir api."""
562
568
        request = smart_dir.SmartServerRequestBzrDirInitializeEx(backing)
563
569
        self.make_controldir('subdir')
564
570
        self.assertRaises(errors.FileExists, request.execute, name, b'subdir',
565
 
                          b'False', b'False', b'False', b'', b'', b'', b'', b'False')
 
571
                          b'False', b'False', b'False', b'', b'', b'', b'',
 
572
                          b'False')
566
573
 
567
574
 
568
575
class TestSmartServerRequestOpenBzrDir(tests.TestCaseWithMemoryTransport):
582
589
 
583
590
    def test_outside_root_client_path(self):
584
591
        backing = self.get_transport()
585
 
        request = smart_dir.SmartServerRequestOpenBzrDir(backing,
586
 
                                                         root_client_path='root')
 
592
        request = smart_dir.SmartServerRequestOpenBzrDir(
 
593
            backing, root_client_path='root')
587
594
        self.assertEqual(smart_req.SmartServerResponse((b'no', )),
588
595
                         request.execute(b'not-root'))
589
596
 
612
619
 
613
620
    def test_outside_root_client_path(self):
614
621
        backing = self.get_transport()
615
 
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(backing,
616
 
                                                             root_client_path='root')
 
622
        request = smart_dir.SmartServerRequestOpenBzrDir_2_1(
 
623
            backing, root_client_path='root')
617
624
        self.assertEqual(smart_req.SmartServerResponse((b'no',)),
618
625
                         request.execute(b'not-root'))
619
626
 
667
674
        """When there is a repository, the error should return details."""
668
675
        backing = self.get_transport()
669
676
        request = smart_dir.SmartServerRequestOpenBranch(backing)
670
 
        repo = self.make_repository('.')
 
677
        self.make_repository('.')
671
678
        self.assertEqual(smart_req.SmartServerResponse((b'nobranch',)),
672
679
                         request.execute(b''))
673
680
 
730
737
        """When there is a repository, the error should return details."""
731
738
        backing = self.get_transport()
732
739
        request = smart_dir.SmartServerRequestOpenBranchV2(backing)
733
 
        repo = self.make_repository('.')
 
740
        self.make_repository('.')
734
741
        self.assertEqual(smart_req.SmartServerResponse((b'nobranch',)),
735
742
                         request.execute(b''))
736
743
 
793
800
        """When there is a repository, the error should return details."""
794
801
        backing = self.get_transport()
795
802
        request = smart_dir.SmartServerRequestOpenBranchV3(backing)
796
 
        repo = self.make_repository('.')
 
803
        self.make_repository('.')
797
804
        self.assertEqual(smart_req.SmartServerResponse(
798
805
            (b'nobranch', b'location is a repository')),
799
806
            request.execute(b''))
839
846
        backing = self.get_transport()
840
847
        request = smart_branch.SmartServerBranchRequest(backing)
841
848
        branch = self.make_branch('branch')
842
 
        checkout = branch.create_checkout('reference', lightweight=True)
 
849
        branch.create_checkout('reference', lightweight=True)
843
850
        self.assertRaises(errors.NotBranchError,
844
851
                          request.execute, b'checkout')
845
852
 
853
860
        request = smart_branch.SmartServerBranchRequestLastRevisionInfo(
854
861
            backing)
855
862
        self.make_branch('.')
856
 
        self.assertEqual(smart_req.SmartServerResponse((b'ok', b'0', b'null:')),
857
 
                         request.execute(b''))
 
863
        self.assertEqual(
 
864
            smart_req.SmartServerResponse((b'ok', b'0', b'null:')),
 
865
            request.execute(b''))
858
866
 
859
867
    def test_ghost(self):
860
868
        """For an empty branch, the result is ('ok', '0', b'null:')."""
878
886
        tree.lock_write()
879
887
        tree.add('')
880
888
        rev_id_utf8 = u'\xc8'.encode('utf-8')
881
 
        r1 = tree.commit('1st commit')
882
 
        r2 = tree.commit('2nd commit', rev_id=rev_id_utf8)
 
889
        tree.commit('1st commit')
 
890
        tree.commit('2nd commit', rev_id=rev_id_utf8)
883
891
        tree.unlock()
884
892
        self.assertEqual(
885
893
            smart_req.SmartServerResponse((b'ok', b'2', rev_id_utf8)),
914
922
        backing = self.get_transport()
915
923
        request = smart_branch.SmartServerBranchRequestRevisionIdToRevno(
916
924
            backing)
917
 
        branch = self.make_branch('.')
 
925
        self.make_branch('.')
918
926
        self.assertEqual(
919
927
            smart_req.FailedSmartServerResponse(
920
928
                (b'NoSuchRevision', b'idontexist')),
928
936
        """With no file, we get empty content."""
929
937
        backing = self.get_transport()
930
938
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
931
 
        branch = self.make_branch('.')
 
939
        self.make_branch('.')
932
940
        # there should be no file by default
933
941
        content = b''
934
942
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), content),
936
944
 
937
945
    def test_with_content(self):
938
946
        # SmartServerBranchGetConfigFile should return the content from
939
 
        # branch.control_files.get('branch.conf') for now - in the future it may
940
 
        # perform more complex processing.
 
947
        # branch.control_files.get('branch.conf') for now - in the future it
 
948
        # may perform more complex processing.
941
949
        backing = self.get_transport()
942
950
        request = smart_branch.SmartServerBranchGetConfigFile(backing)
943
951
        branch = self.make_branch('.')
944
952
        branch._transport.put_bytes('branch.conf', b'foo bar baz')
945
 
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), b'foo bar baz'),
946
 
                         request.execute(b''))
 
953
        self.assertEqual(
 
954
            smart_req.SmartServerResponse((b'ok', ), b'foo bar baz'),
 
955
            request.execute(b''))
947
956
 
948
957
 
949
958
class TestLockedBranch(tests.TestCaseWithMemoryTransport):
1114
1123
        """If the revision_id is not present, the verb returns NoSuchRevision.
1115
1124
        """
1116
1125
        revision_id = b'non-existent revision'
1117
 
        self.assertEqual(smart_req.FailedSmartServerResponse((b'NoSuchRevision',
1118
 
                                                              revision_id)),
1119
 
                         self.set_last_revision(revision_id, 1))
 
1126
        self.assertEqual(
 
1127
            smart_req.FailedSmartServerResponse(
 
1128
                (b'NoSuchRevision', revision_id)),
 
1129
            self.set_last_revision(revision_id, 1))
1120
1130
 
1121
1131
    def make_tree_with_two_commits(self):
1122
1132
        self.tree.lock_write()
1123
1133
        self.tree.add('')
1124
1134
        rev_id_utf8 = u'\xc8'.encode('utf-8')
1125
 
        r1 = self.tree.commit('1st commit', rev_id=rev_id_utf8)
1126
 
        r2 = self.tree.commit('2nd commit', rev_id=b'rev-2')
 
1135
        self.tree.commit('1st commit', rev_id=rev_id_utf8)
 
1136
        self.tree.commit('2nd commit', rev_id=b'rev-2')
1127
1137
        self.tree.unlock()
1128
1138
 
1129
1139
    def test_branch_last_revision_info_is_updated(self):
1254
1264
        """
1255
1265
        self.tree.lock_write()
1256
1266
        self.tree.add('')
1257
 
        r1 = self.tree.commit('1st commit')
 
1267
        self.tree.commit('1st commit')
1258
1268
        revno_1, revid_1 = self.tree.branch.last_revision_info()
1259
 
        r2 = self.tree.commit('2nd commit', rev_id=b'child-1')
 
1269
        self.tree.commit('2nd commit', rev_id=b'child-1')
1260
1270
        # Undo the second commit
1261
1271
        self.tree.branch.set_last_revision_info(revno_1, revid_1)
1262
1272
        self.tree.set_parent_ids([revid_1])
1263
1273
        # Make a new second commit, child-2.  child-2 has diverged from
1264
1274
        # child-1.
1265
 
        new_r2 = self.tree.commit('2nd commit', rev_id=b'child-2')
 
1275
        self.tree.commit('2nd commit', rev_id=b'child-2')
1266
1276
        self.tree.unlock()
1267
1277
 
1268
1278
    def test_not_allow_diverged(self):
1304
1314
            request.execute(b'base'))
1305
1315
 
1306
1316
    def test_nothing_to_break(self):
1307
 
        base_branch = self.make_branch('base')
 
1317
        self.make_branch('base')
1308
1318
        request = smart_branch.SmartServerBranchBreakLock(
1309
1319
            self.get_transport())
1310
1320
        self.assertEqual(
1315
1325
class TestSmartServerBranchRequestGetParent(tests.TestCaseWithMemoryTransport):
1316
1326
 
1317
1327
    def test_get_parent_none(self):
1318
 
        base_branch = self.make_branch('base')
 
1328
        self.make_branch('base')
1319
1329
        request = smart_branch.SmartServerBranchGetParent(self.get_transport())
1320
1330
        response = request.execute(b'base')
1321
1331
        self.assertEqual(
1371
1381
    # methods] so only need to test straight forward cases.
1372
1382
 
1373
1383
    def test_get_bytes(self):
1374
 
        base_branch = self.make_branch('base')
 
1384
        self.make_branch('base')
1375
1385
        request = smart_branch.SmartServerBranchGetTagsBytes(
1376
1386
            self.get_transport())
1377
1387
        response = request.execute(b'base')
1379
1389
            smart_req.SuccessfulSmartServerResponse((b'',)), response)
1380
1390
 
1381
1391
 
1382
 
class TestSmartServerBranchRequestGetStackedOnURL(tests.TestCaseWithMemoryTransport):
 
1392
class TestSmartServerBranchRequestGetStackedOnURL(
 
1393
        tests.TestCaseWithMemoryTransport):
1383
1394
 
1384
1395
    def test_get_stacked_on_url(self):
1385
 
        base_branch = self.make_branch('base', format='1.6')
 
1396
        self.make_branch('base', format='1.6')
1386
1397
        stacked_branch = self.make_branch('stacked', format='1.6')
1387
1398
        # typically should be relative
1388
1399
        stacked_branch.set_stacked_on_url('../base')
1490
1501
    def test_lock_write_on_readonly_transport(self):
1491
1502
        backing = self.get_readonly_transport()
1492
1503
        request = smart_branch.SmartServerBranchRequestLockWrite(backing)
1493
 
        branch = self.make_branch('.')
 
1504
        self.make_branch('.')
1494
1505
        root = self.get_transport().clone('/')
1495
1506
        path = urlutils.relative_url(root.base, self.get_transport().base)
1496
1507
        response = request.execute(path.encode('utf-8'))
1550
1561
    def test_unlock_on_unlocked_branch_unlocked_repo(self):
1551
1562
        backing = self.get_transport()
1552
1563
        request = smart_branch.SmartServerBranchRequestUnlock(backing)
1553
 
        branch = self.make_branch('.', format='knit')
 
1564
        self.make_branch('.', format='knit')
1554
1565
        response = request.execute(
1555
1566
            b'', b'branch token', b'repo token')
1556
1567
        self.assertEqual(
1591
1602
                          request.execute, b'subdir')
1592
1603
 
1593
1604
 
1594
 
class TestSmartServerRepositoryAddSignatureText(tests.TestCaseWithMemoryTransport):
 
1605
class TestSmartServerRepositoryAddSignatureText(
 
1606
        tests.TestCaseWithMemoryTransport):
1595
1607
 
1596
1608
    def test_add_text(self):
1597
1609
        backing = self.get_transport()
1603
1615
        tree.commit("Message", rev_id=b'rev1')
1604
1616
        tree.branch.repository.start_write_group()
1605
1617
        write_group_tokens = tree.branch.repository.suspend_write_group()
1606
 
        self.assertEqual(None, request.execute(b'', write_token,
1607
 
                                               b'rev1', *[token.encode('utf-8') for token in write_group_tokens]))
 
1618
        self.assertEqual(
 
1619
            None, request.execute(
 
1620
                b'', write_token, b'rev1',
 
1621
                *[token.encode('utf-8') for token in write_group_tokens]))
1608
1622
        response = request.do_body(b'somesignature')
1609
1623
        self.assertTrue(response.is_successful())
1610
1624
        self.assertEqual(response.args[0], b'ok')
1641
1655
        tree.unlock()
1642
1656
        self.assertIn(
1643
1657
            request.execute(b''),
1644
 
            [smart_req.SuccessfulSmartServerResponse((b"ok", ),
1645
 
                                                     b"origineel\nnog-een-revisie"),
1646
 
             smart_req.SuccessfulSmartServerResponse((b"ok", ),
1647
 
                                                     b"nog-een-revisie\norigineel")])
 
1658
            [smart_req.SuccessfulSmartServerResponse(
 
1659
                (b"ok", ), b"origineel\nnog-een-revisie"),
 
1660
             smart_req.SuccessfulSmartServerResponse(
 
1661
                 (b"ok", ), b"nog-een-revisie\norigineel")])
1648
1662
 
1649
1663
 
1650
1664
class TestSmartServerRepositoryBreakLock(tests.TestCaseWithMemoryTransport):
1661
1675
    def test_nothing_to_break(self):
1662
1676
        backing = self.get_transport()
1663
1677
        request = smart_repo.SmartServerRepositoryBreakLock(backing)
1664
 
        tree = self.make_branch_and_memory_tree('.')
 
1678
        self.make_branch_and_memory_tree('.')
1665
1679
        self.assertEqual(
1666
1680
            smart_req.SuccessfulSmartServerResponse((b'ok', ), None),
1667
1681
            request.execute(b''))
1673
1687
        # This tests that the wire encoding is actually bzipped
1674
1688
        backing = self.get_transport()
1675
1689
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1676
 
        tree = self.make_branch_and_memory_tree('.')
 
1690
        self.make_branch_and_memory_tree('.')
1677
1691
 
1678
1692
        self.assertEqual(None,
1679
1693
                         request.execute(b'', b'missing-id'))
1686
1700
    def test_trivial_include_missing(self):
1687
1701
        backing = self.get_transport()
1688
1702
        request = smart_repo.SmartServerRepositoryGetParentMap(backing)
1689
 
        tree = self.make_branch_and_memory_tree('.')
 
1703
        self.make_branch_and_memory_tree('.')
1690
1704
 
1691
 
        self.assertEqual(None,
1692
 
                         request.execute(b'', b'missing-id', b'include-missing:'))
1693
 
        self.assertEqual(
1694
 
            smart_req.SuccessfulSmartServerResponse((b'ok', ),
1695
 
                                                    bz2.compress(b'missing:missing-id')),
 
1705
        self.assertEqual(
 
1706
            None, request.execute(b'', b'missing-id', b'include-missing:'))
 
1707
        self.assertEqual(
 
1708
            smart_req.SuccessfulSmartServerResponse(
 
1709
                (b'ok', ), bz2.compress(b'missing:missing-id')),
1696
1710
            request.do_body(b'\n\n0\n'))
1697
1711
 
1698
1712
 
1716
1730
        response.body = b'\n'.join(sorted(response.body.split(b'\n')))
1717
1731
 
1718
1732
        self.assertEqual(
1719
 
            smart_req.SmartServerResponse((b'ok', ), b'\n'.join(lines)), response)
 
1733
            smart_req.SmartServerResponse((b'ok', ), b'\n'.join(lines)),
 
1734
            response)
1720
1735
 
1721
1736
    def test_specific_revision_argument(self):
1722
1737
        backing = self.get_transport()
1725
1740
        tree.lock_write()
1726
1741
        tree.add('')
1727
1742
        rev_id_utf8 = u'\xc9'.encode('utf-8')
1728
 
        r1 = tree.commit('1st commit', rev_id=rev_id_utf8)
1729
 
        r2 = tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
 
1743
        tree.commit('1st commit', rev_id=rev_id_utf8)
 
1744
        tree.commit('2nd commit', rev_id=u'\xc8'.encode('utf-8'))
1730
1745
        tree.unlock()
1731
1746
 
1732
1747
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), rev_id_utf8),
1738
1753
        tree = self.make_branch_and_memory_tree('.')
1739
1754
        tree.lock_write()
1740
1755
        tree.add('')
1741
 
        r1 = tree.commit('1st commit')
 
1756
        tree.commit('1st commit')
1742
1757
        tree.unlock()
1743
1758
 
1744
1759
        # Note that it still returns body (of zero bytes).
1768
1783
    def test_known_revid_missing(self):
1769
1784
        backing = self.get_transport()
1770
1785
        request = smart_repo.SmartServerRepositoryGetRevIdForRevno(backing)
1771
 
        repo = self.make_repository('.')
 
1786
        self.make_repository('.')
1772
1787
        self.assertEqual(
1773
1788
            smart_req.FailedSmartServerResponse((b'nosuchrevision', b'ghost')),
1774
1789
            request.execute(b'', 1, (2, b'ghost')))
1779
1794
        parent = self.make_branch_and_memory_tree('parent', format='1.9')
1780
1795
        parent.lock_write()
1781
1796
        parent.add([''], [b'TREE_ROOT'])
1782
 
        r1 = parent.commit(message='first commit')
 
1797
        parent.commit(message='first commit')
1783
1798
        r2 = parent.commit(message='second commit')
1784
1799
        parent.unlock()
1785
1800
        local = self.make_branch_and_memory_tree('local', format='1.9')
1825
1840
    def test_missing(self):
1826
1841
        backing = self.get_transport()
1827
1842
        request = smart_repo.SmartServerRepositoryIterRevisions(backing)
1828
 
        tree = self.make_branch_and_memory_tree('.', format='2a')
 
1843
        self.make_branch_and_memory_tree('.', format='2a')
1829
1844
 
1830
1845
        self.assertIs(None, request.execute(b''))
1831
1846
        response = request.do_body(b"rev1\nrev2")
1909
1924
        tree.lock_write()
1910
1925
        tree.add('')
1911
1926
        rev_id_utf8 = u'\xc8abc'.encode('utf-8')
1912
 
        r1 = tree.commit('a commit', rev_id=rev_id_utf8)
 
1927
        tree.commit('a commit', rev_id=rev_id_utf8)
1913
1928
        tree.unlock()
1914
1929
        self.assertTrue(tree.branch.repository.has_revision(rev_id_utf8))
1915
1930
        self.assertEqual(smart_req.SmartServerResponse((b'yes', )),
1968
1983
        tree = self.make_branch_and_memory_tree('.')
1969
1984
        tree.lock_write()
1970
1985
        tree.add('')
1971
 
        r1 = tree.commit('a commit', rev_id=b'A')
 
1986
        tree.commit('a commit', rev_id=b'A')
1972
1987
        tree.unlock()
1973
1988
        self.assertTrue(tree.branch.repository.has_revision(b'A'))
1974
1989
        self.assertEqual(smart_req.SmartServerResponse((b'no', )),
1983
1998
        tree = self.make_branch_and_memory_tree('.')
1984
1999
        tree.lock_write()
1985
2000
        tree.add('')
1986
 
        r1 = tree.commit('a commit', rev_id=b'A')
 
2001
        tree.commit('a commit', rev_id=b'A')
1987
2002
        tree.branch.repository.start_write_group()
1988
2003
        tree.branch.repository.sign_revision(b'A', strategy)
1989
2004
        tree.branch.repository.commit_write_group()
2000
2015
        backing = self.get_transport()
2001
2016
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
2002
2017
        repository = self.make_repository('.')
2003
 
        stats = repository.gather_stats()
 
2018
        repository.gather_stats()
2004
2019
        expected_body = b'revisions: 0\n'
2005
 
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), expected_body),
2006
 
                         request.execute(b'', b'', b'no'))
 
2020
        self.assertEqual(
 
2021
            smart_req.SmartServerResponse((b'ok', ), expected_body),
 
2022
            request.execute(b'', b'', b'no'))
2007
2023
 
2008
2024
    def test_revid_with_committers(self):
2009
2025
        """For a revid we get more infos."""
2019
2035
                    rev_id=rev_id_utf8)
2020
2036
        tree.unlock()
2021
2037
 
2022
 
        stats = tree.branch.repository.gather_stats()
 
2038
        tree.branch.repository.gather_stats()
2023
2039
        expected_body = (b'firstrev: 123456.200 3600\n'
2024
2040
                         b'latestrev: 654321.400 0\n'
2025
2041
                         b'revisions: 2\n')
2026
 
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), expected_body),
2027
 
                         request.execute(b'', rev_id_utf8, b'no'))
 
2042
        self.assertEqual(
 
2043
            smart_req.SmartServerResponse((b'ok', ), expected_body),
 
2044
            request.execute(b'', rev_id_utf8, b'no'))
2028
2045
 
2029
2046
    def test_not_empty_repository_with_committers(self):
2030
2047
        """For a revid and requesting committers we get the whole thing."""
2040
2057
        tree.commit('a commit', timestamp=654321.4, timezone=0,
2041
2058
                    committer='bar', rev_id=rev_id_utf8)
2042
2059
        tree.unlock()
2043
 
        stats = tree.branch.repository.gather_stats()
 
2060
        tree.branch.repository.gather_stats()
2044
2061
 
2045
2062
        expected_body = (b'committers: 2\n'
2046
2063
                         b'firstrev: 123456.200 3600\n'
2047
2064
                         b'latestrev: 654321.400 0\n'
2048
2065
                         b'revisions: 2\n')
2049
 
        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), expected_body),
2050
 
                         request.execute(b'',
2051
 
                                         rev_id_utf8, b'yes'))
 
2066
        self.assertEqual(
 
2067
            smart_req.SmartServerResponse((b'ok', ), expected_body),
 
2068
            request.execute(b'', rev_id_utf8, b'yes'))
2052
2069
 
2053
2070
    def test_unknown_revid(self):
2054
2071
        """An unknown revision id causes a 'nosuchrevision' error."""
2055
2072
        backing = self.get_transport()
2056
2073
        request = smart_repo.SmartServerRepositoryGatherStats(backing)
2057
 
        repository = self.make_repository('.')
2058
 
        expected_body = b'revisions: 0\n'
 
2074
        self.make_repository('.')
2059
2075
        self.assertEqual(
2060
2076
            smart_req.FailedSmartServerResponse(
2061
2077
                (b'nosuchrevision', b'mia'), None),
2163
2179
    def test_lock_write_on_readonly_transport(self):
2164
2180
        backing = self.get_readonly_transport()
2165
2181
        request = smart_repo.SmartServerRepositoryLockWrite(backing)
2166
 
        repository = self.make_repository('.', format='knit')
 
2182
        self.make_repository('.', format='knit')
2167
2183
        response = request.execute(b'')
2168
2184
        self.assertFalse(response.is_successful())
2169
2185
        self.assertEqual(b'LockFailed', response.args[0])
2211
2227
        request = smart_repo.SmartServerRepositoryInsertStreamLocked(
2212
2228
            backing)
2213
2229
        repository = self.make_repository('.', format='knit')
2214
 
        lock_token = repository.lock_write().repository_token
2215
 
        self.assertRaises(
2216
 
            errors.TokenMismatch, request.execute, b'', b'', b'wrong-token')
2217
 
        repository.unlock()
 
2230
        with repository.lock_write():
 
2231
            self.assertRaises(
 
2232
                errors.TokenMismatch, request.execute, b'', b'',
 
2233
                b'wrong-token')
2218
2234
 
2219
2235
 
2220
2236
class TestSmartServerRepositoryUnlock(tests.TestCaseWithMemoryTransport):
2238
2254
    def test_unlock_on_unlocked_repo(self):
2239
2255
        backing = self.get_transport()
2240
2256
        request = smart_repo.SmartServerRepositoryUnlock(backing)
2241
 
        repository = self.make_repository('.', format='knit')
 
2257
        self.make_repository('.', format='knit')
2242
2258
        response = request.execute(b'', b'some token')
2243
2259
        self.assertEqual(
2244
2260
            smart_req.SmartServerResponse((b'TokenMismatch',)), response)