/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 bzrlib/tests/test_remote.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-29 21:35:05 UTC
  • mfrom: (4576 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4577.
  • Revision ID: john@arbash-meinel.com-20090729213505-tkqsvy1zfpocu75w
Merge bzr.dev 4576 in prep for NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
58
58
    condition_isinstance,
59
59
    split_suite_by_condition,
60
60
    multiply_tests,
 
61
    KnownFailure,
61
62
    )
62
63
from bzrlib.transport import get_transport, http
63
64
from bzrlib.transport.memory import MemoryTransport
153
154
        r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
154
155
        self.assertTrue(r._format.supports_external_lookups)
155
156
 
 
157
    def test_remote_branch_set_append_revisions_only(self):
 
158
        # Make a format 1.9 branch, which supports append_revisions_only
 
159
        branch = self.make_branch('branch', format='1.9')
 
160
        config = branch.get_config()
 
161
        branch.set_append_revisions_only(True)
 
162
        self.assertEqual(
 
163
            'True', config.get_user_option('append_revisions_only'))
 
164
        branch.set_append_revisions_only(False)
 
165
        self.assertEqual(
 
166
            'False', config.get_user_option('append_revisions_only'))
 
167
 
 
168
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
 
169
        branch = self.make_branch('branch', format='knit')
 
170
        config = branch.get_config()
 
171
        self.assertRaises(
 
172
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
 
173
 
156
174
 
157
175
class FakeProtocol(object):
158
176
    """Lookalike SmartClientRequestProtocolOne allowing body reading tests."""
323
341
            request_handlers.register(verb, orig_method)
324
342
        self.addCleanup(restoreVerb)
325
343
 
 
344
    def assertFinished(self, fake_client):
 
345
        """Assert that all of a FakeClient's expected calls have occurred."""
 
346
        fake_client.finished_test()
 
347
 
326
348
 
327
349
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
328
350
    """Tests for the behaviour of client_medium.remote_path_from_transport."""
428
450
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
429
451
        self.assertEqual(expected._repository_format, result._repository_format)
430
452
        self.assertEqual(expected._branch_format, result._branch_format)
431
 
        client.finished_test()
 
453
        self.assertFinished(client)
432
454
 
433
455
    def test_current_server(self):
434
456
        transport = self.get_transport('.')
449
471
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
450
472
        self.assertEqual(None, result._repository_format)
451
473
        self.assertEqual(None, result._branch_format)
452
 
        client.finished_test()
 
474
        self.assertFinished(client)
453
475
 
454
476
 
455
477
class TestBzrDirOpenBranch(TestRemote):
488
510
        result = bzrdir.open_branch()
489
511
        self.assertIsInstance(result, RemoteBranch)
490
512
        self.assertEqual(bzrdir, result.bzrdir)
491
 
        client.finished_test()
 
513
        self.assertFinished(client)
492
514
 
493
515
    def test_branch_missing(self):
494
516
        transport = MemoryTransport()
541
563
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
542
564
            _client=client)
543
565
        result = bzrdir.open_branch()
544
 
        client.finished_test()
 
566
        self.assertFinished(client)
545
567
 
546
568
    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
547
569
        reference_format = self.get_repo_format()
750
772
        transport = self.get_transport()
751
773
        client = FakeClient(transport.base)
752
774
        client.add_expected_call(
753
 
            'BzrDirFormat.initialize_ex',
 
775
            'BzrDirFormat.initialize_ex_1.16',
754
776
                (default_format_name, 'path', 'False', 'False', 'False', '',
755
777
                 '', '', '', 'False'),
756
778
            'success',
761
783
        # transport connected to a real server.
762
784
        result = fmt._initialize_on_transport_ex_rpc(client, 'path',
763
785
            transport, False, False, False, None, None, None, None, False)
764
 
        client.finished_test()
 
786
        self.assertFinished(client)
765
787
 
766
788
    def test_error(self):
767
789
        """Error responses are translated, e.g. 'PermissionDenied' raises the
772
794
        transport = self.get_transport()
773
795
        client = FakeClient(transport.base)
774
796
        client.add_expected_call(
775
 
            'BzrDirFormat.initialize_ex',
 
797
            'BzrDirFormat.initialize_ex_1.16',
776
798
                (default_format_name, 'path', 'False', 'False', 'False', '',
777
799
                 '', '', '', 'False'),
778
800
            'error',
785
807
            False, False, False, None, None, None, None, False)
786
808
        self.assertEqual('path', err.path)
787
809
        self.assertEqual(': extra info', err.extra)
788
 
        client.finished_test()
 
810
        self.assertFinished(client)
789
811
 
790
812
    def test_error_from_real_server(self):
791
813
        """Integration test for error translation."""
866
888
        transport = transport.clone('quack')
867
889
        branch = self.make_remote_branch(transport, client)
868
890
        result = branch.get_parent()
869
 
        client.finished_test()
 
891
        self.assertFinished(client)
870
892
        self.assertEqual(None, result)
871
893
 
872
894
    def test_parent_relative(self):
898
920
        branch = self.make_remote_branch(transport, client)
899
921
        result = branch.get_parent()
900
922
        self.assertEqual('http://foo/', result)
901
 
        client.finished_test()
 
923
        self.assertFinished(client)
902
924
 
903
925
 
904
926
class TestBranchSetParentLocation(RemoteBranchTestCase):
919
941
        branch._lock_token = 'b'
920
942
        branch._repo_lock_token = 'r'
921
943
        branch._set_parent_location(None)
922
 
        client.finished_test()
 
944
        self.assertFinished(client)
923
945
 
924
946
    def test_parent(self):
925
947
        transport = MemoryTransport()
936
958
        branch._lock_token = 'b'
937
959
        branch._repo_lock_token = 'r'
938
960
        branch._set_parent_location('foo')
939
 
        client.finished_test()
 
961
        self.assertFinished(client)
940
962
 
941
963
    def test_backwards_compat(self):
942
964
        self.setup_smart_server_with_call_log()
974
996
        transport = transport.clone('quack')
975
997
        branch = self.make_remote_branch(transport, client)
976
998
        result = branch.tags.get_tag_dict()
977
 
        client.finished_test()
 
999
        self.assertFinished(client)
978
1000
        self.assertEqual({}, result)
979
1001
 
980
1002
 
994
1016
        transport = transport.clone('quack')
995
1017
        branch = self.make_remote_branch(transport, client)
996
1018
        result = branch.last_revision_info()
997
 
        client.finished_test()
 
1019
        self.assertFinished(client)
998
1020
        self.assertEqual((0, NULL_REVISION), result)
999
1021
 
1000
1022
    def test_non_empty_branch(self):
1075
1097
        branch = bzrdir.open_branch()
1076
1098
        result = branch.get_stacked_on_url()
1077
1099
        self.assertEqual('../base', result)
1078
 
        client.finished_test()
 
1100
        self.assertFinished(client)
1079
1101
        # it's in the fallback list both for the RemoteRepository and its vfs
1080
1102
        # repository
1081
1103
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1108
1130
        branch = bzrdir.open_branch()
1109
1131
        result = branch.get_stacked_on_url()
1110
1132
        self.assertEqual('../base', result)
1111
 
        client.finished_test()
 
1133
        self.assertFinished(client)
1112
1134
        # it's in the fallback list both for the RemoteRepository.
1113
1135
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1114
1136
        # And we haven't had to construct a real repository.
1149
1171
        result = branch.set_revision_history([])
1150
1172
        branch.unlock()
1151
1173
        self.assertEqual(None, result)
1152
 
        client.finished_test()
 
1174
        self.assertFinished(client)
1153
1175
 
1154
1176
    def test_set_nonempty(self):
1155
1177
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1187
1209
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1188
1210
        branch.unlock()
1189
1211
        self.assertEqual(None, result)
1190
 
        client.finished_test()
 
1212
        self.assertFinished(client)
1191
1213
 
1192
1214
    def test_no_such_revision(self):
1193
1215
        transport = MemoryTransport()
1222
1244
        self.assertRaises(
1223
1245
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1224
1246
        branch.unlock()
1225
 
        client.finished_test()
 
1247
        self.assertFinished(client)
1226
1248
 
1227
1249
    def test_tip_change_rejected(self):
1228
1250
        """TipChangeRejected responses cause a TipChangeRejected exception to
1265
1287
        self.assertIsInstance(err.msg, unicode)
1266
1288
        self.assertEqual(rejection_msg_unicode, err.msg)
1267
1289
        branch.unlock()
1268
 
        client.finished_test()
 
1290
        self.assertFinished(client)
1269
1291
 
1270
1292
 
1271
1293
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1381
1403
        self.assertEqual(
1382
1404
            [('set_last_revision_info', 1234, 'a-revision-id')],
1383
1405
            real_branch.calls)
1384
 
        client.finished_test()
 
1406
        self.assertFinished(client)
1385
1407
 
1386
1408
    def test_unexpected_error(self):
1387
1409
        # If the server sends an error the client doesn't understand, it gets
1495
1517
        config = branch._get_config()
1496
1518
        config.set_option('foo', 'bar')
1497
1519
        branch.unlock()
1498
 
        client.finished_test()
 
1520
        self.assertFinished(client)
1499
1521
 
1500
1522
    def test_backwards_compat_set_option(self):
1501
1523
        self.setup_smart_server_with_call_log()
1525
1547
        transport = transport.clone('quack')
1526
1548
        branch = self.make_remote_branch(transport, client)
1527
1549
        self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1528
 
        client.finished_test()
 
1550
        self.assertFinished(client)
1529
1551
 
1530
1552
 
1531
1553
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
2018
2040
        self.assertEqual(('AnUnexpectedError',), e.error_tuple)
2019
2041
 
2020
2042
 
 
2043
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
 
2044
 
 
2045
    def test_ok(self):
 
2046
        repo, client = self.setup_fake_client_and_repository('quack')
 
2047
        client.add_expected_call(
 
2048
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2049
            'success', ('ok', 'rev-five'))
 
2050
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
 
2051
        self.assertEqual((True, 'rev-five'), result)
 
2052
        self.assertFinished(client)
 
2053
 
 
2054
    def test_history_incomplete(self):
 
2055
        repo, client = self.setup_fake_client_and_repository('quack')
 
2056
        client.add_expected_call(
 
2057
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2058
            'success', ('history-incomplete', 10, 'rev-ten'))
 
2059
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
 
2060
        self.assertEqual((False, (10, 'rev-ten')), result)
 
2061
        self.assertFinished(client)
 
2062
 
 
2063
    def test_history_incomplete_with_fallback(self):
 
2064
        """A 'history-incomplete' response causes the fallback repository to be
 
2065
        queried too, if one is set.
 
2066
        """
 
2067
        # Make a repo with a fallback repo, both using a FakeClient.
 
2068
        format = remote.response_tuple_to_repo_format(
 
2069
            ('yes', 'no', 'yes', 'fake-network-name'))
 
2070
        repo, client = self.setup_fake_client_and_repository('quack')
 
2071
        repo._format = format
 
2072
        fallback_repo, ignored = self.setup_fake_client_and_repository(
 
2073
            'fallback')
 
2074
        fallback_repo._client = client
 
2075
        repo.add_fallback_repository(fallback_repo)
 
2076
        # First the client should ask the primary repo
 
2077
        client.add_expected_call(
 
2078
            'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
 
2079
            'success', ('history-incomplete', 2, 'rev-two'))
 
2080
        # Then it should ask the fallback, using revno/revid from the
 
2081
        # history-incomplete response as the known revno/revid.
 
2082
        client.add_expected_call(
 
2083
            'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
 
2084
            'success', ('ok', 'rev-one'))
 
2085
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
 
2086
        self.assertEqual((True, 'rev-one'), result)
 
2087
        self.assertFinished(client)
 
2088
 
 
2089
    def test_nosuchrevision(self):
 
2090
        # 'nosuchrevision' is returned when the known-revid is not found in the
 
2091
        # remote repo.  The client translates that response to NoSuchRevision.
 
2092
        repo, client = self.setup_fake_client_and_repository('quack')
 
2093
        client.add_expected_call(
 
2094
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
 
2095
            'error', ('nosuchrevision', 'rev-foo'))
 
2096
        self.assertRaises(
 
2097
            errors.NoSuchRevision,
 
2098
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
 
2099
        self.assertFinished(client)
 
2100
 
 
2101
 
2021
2102
class TestRepositoryIsShared(TestRemoteRepository):
2022
2103
 
2023
2104
    def test_is_shared(self):
2154
2235
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2155
2236
        self.assertEqual([], resume_tokens)
2156
2237
        self.assertEqual(set(), missing_keys)
2157
 
        client.finished_test()
 
2238
        self.assertFinished(client)
2158
2239
 
2159
2240
    def test_locked_repo_with_no_lock_token(self):
2160
2241
        transport_path = 'quack'
2174
2255
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2175
2256
        self.assertEqual([], resume_tokens)
2176
2257
        self.assertEqual(set(), missing_keys)
2177
 
        client.finished_test()
 
2258
        self.assertFinished(client)
2178
2259
 
2179
2260
    def test_locked_repo_with_lock_token(self):
2180
2261
        transport_path = 'quack'
2194
2275
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2195
2276
        self.assertEqual([], resume_tokens)
2196
2277
        self.assertEqual(set(), missing_keys)
2197
 
        client.finished_test()
 
2278
        self.assertFinished(client)
2198
2279
 
2199
2280
 
2200
2281
class TestRepositoryTarball(TestRemoteRepository):
2285
2366
        client.add_expected_call(
2286
2367
            'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2287
2368
        repo.autopack()
2288
 
        client.finished_test()
 
2369
        self.assertFinished(client)
2289
2370
 
2290
2371
    def test_ok_with_real_repo(self):
2291
2372
        """When the server returns 'ok' and there is a _real_repository, then