← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Martin Pool
  • Date: 2009-07-24 03:15:56 UTC
  • mfrom: (4565 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4566.
  • Revision ID: mbp@sourcefrog.net-20090724031556-5zyef6f1ixtn6r3z
merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
341
341
            request_handlers.register(verb, orig_method)
342
342
        self.addCleanup(restoreVerb)
343
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
 
344
348
 
345
349
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
346
350
    """Tests for the behaviour of client_medium.remote_path_from_transport."""
446
450
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
447
451
        self.assertEqual(expected._repository_format, result._repository_format)
448
452
        self.assertEqual(expected._branch_format, result._branch_format)
449
 
        client.finished_test()
 
453
        self.assertFinished(client)
450
454
 
451
455
    def test_current_server(self):
452
456
        transport = self.get_transport('.')
467
471
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
468
472
        self.assertEqual(None, result._repository_format)
469
473
        self.assertEqual(None, result._branch_format)
470
 
        client.finished_test()
 
474
        self.assertFinished(client)
471
475
 
472
476
 
473
477
class TestBzrDirOpenBranch(TestRemote):
506
510
        result = bzrdir.open_branch()
507
511
        self.assertIsInstance(result, RemoteBranch)
508
512
        self.assertEqual(bzrdir, result.bzrdir)
509
 
        client.finished_test()
 
513
        self.assertFinished(client)
510
514
 
511
515
    def test_branch_missing(self):
512
516
        transport = MemoryTransport()
559
563
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
560
564
            _client=client)
561
565
        result = bzrdir.open_branch()
562
 
        client.finished_test()
 
566
        self.assertFinished(client)
563
567
 
564
568
    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
565
569
        reference_format = self.get_repo_format()
779
783
        # transport connected to a real server.
780
784
        result = fmt._initialize_on_transport_ex_rpc(client, 'path',
781
785
            transport, False, False, False, None, None, None, None, False)
782
 
        client.finished_test()
 
786
        self.assertFinished(client)
783
787
 
784
788
    def test_error(self):
785
789
        """Error responses are translated, e.g. 'PermissionDenied' raises the
803
807
            False, False, False, None, None, None, None, False)
804
808
        self.assertEqual('path', err.path)
805
809
        self.assertEqual(': extra info', err.extra)
806
 
        client.finished_test()
 
810
        self.assertFinished(client)
807
811
 
808
812
    def test_error_from_real_server(self):
809
813
        """Integration test for error translation."""
884
888
        transport = transport.clone('quack')
885
889
        branch = self.make_remote_branch(transport, client)
886
890
        result = branch.get_parent()
887
 
        client.finished_test()
 
891
        self.assertFinished(client)
888
892
        self.assertEqual(None, result)
889
893
 
890
894
    def test_parent_relative(self):
916
920
        branch = self.make_remote_branch(transport, client)
917
921
        result = branch.get_parent()
918
922
        self.assertEqual('http://foo/', result)
919
 
        client.finished_test()
 
923
        self.assertFinished(client)
920
924
 
921
925
 
922
926
class TestBranchSetParentLocation(RemoteBranchTestCase):
937
941
        branch._lock_token = 'b'
938
942
        branch._repo_lock_token = 'r'
939
943
        branch._set_parent_location(None)
940
 
        client.finished_test()
 
944
        self.assertFinished(client)
941
945
 
942
946
    def test_parent(self):
943
947
        transport = MemoryTransport()
954
958
        branch._lock_token = 'b'
955
959
        branch._repo_lock_token = 'r'
956
960
        branch._set_parent_location('foo')
957
 
        client.finished_test()
 
961
        self.assertFinished(client)
958
962
 
959
963
    def test_backwards_compat(self):
960
964
        self.setup_smart_server_with_call_log()
992
996
        transport = transport.clone('quack')
993
997
        branch = self.make_remote_branch(transport, client)
994
998
        result = branch.tags.get_tag_dict()
995
 
        client.finished_test()
 
999
        self.assertFinished(client)
996
1000
        self.assertEqual({}, result)
997
1001
 
998
1002
 
1012
1016
        transport = transport.clone('quack')
1013
1017
        branch = self.make_remote_branch(transport, client)
1014
1018
        result = branch.last_revision_info()
1015
 
        client.finished_test()
 
1019
        self.assertFinished(client)
1016
1020
        self.assertEqual((0, NULL_REVISION), result)
1017
1021
 
1018
1022
    def test_non_empty_branch(self):
1093
1097
        branch = bzrdir.open_branch()
1094
1098
        result = branch.get_stacked_on_url()
1095
1099
        self.assertEqual('../base', result)
1096
 
        client.finished_test()
 
1100
        self.assertFinished(client)
1097
1101
        # it's in the fallback list both for the RemoteRepository and its vfs
1098
1102
        # repository
1099
1103
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1126
1130
        branch = bzrdir.open_branch()
1127
1131
        result = branch.get_stacked_on_url()
1128
1132
        self.assertEqual('../base', result)
1129
 
        client.finished_test()
 
1133
        self.assertFinished(client)
1130
1134
        # it's in the fallback list both for the RemoteRepository.
1131
1135
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1132
1136
        # And we haven't had to construct a real repository.
1167
1171
        result = branch.set_revision_history([])
1168
1172
        branch.unlock()
1169
1173
        self.assertEqual(None, result)
1170
 
        client.finished_test()
 
1174
        self.assertFinished(client)
1171
1175
 
1172
1176
    def test_set_nonempty(self):
1173
1177
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1205
1209
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1206
1210
        branch.unlock()
1207
1211
        self.assertEqual(None, result)
1208
 
        client.finished_test()
 
1212
        self.assertFinished(client)
1209
1213
 
1210
1214
    def test_no_such_revision(self):
1211
1215
        transport = MemoryTransport()
1240
1244
        self.assertRaises(
1241
1245
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1242
1246
        branch.unlock()
1243
 
        client.finished_test()
 
1247
        self.assertFinished(client)
1244
1248
 
1245
1249
    def test_tip_change_rejected(self):
1246
1250
        """TipChangeRejected responses cause a TipChangeRejected exception to
1283
1287
        self.assertIsInstance(err.msg, unicode)
1284
1288
        self.assertEqual(rejection_msg_unicode, err.msg)
1285
1289
        branch.unlock()
1286
 
        client.finished_test()
 
1290
        self.assertFinished(client)
1287
1291
 
1288
1292
 
1289
1293
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1399
1403
        self.assertEqual(
1400
1404
            [('set_last_revision_info', 1234, 'a-revision-id')],
1401
1405
            real_branch.calls)
1402
 
        client.finished_test()
 
1406
        self.assertFinished(client)
1403
1407
 
1404
1408
    def test_unexpected_error(self):
1405
1409
        # If the server sends an error the client doesn't understand, it gets
1513
1517
        config = branch._get_config()
1514
1518
        config.set_option('foo', 'bar')
1515
1519
        branch.unlock()
1516
 
        client.finished_test()
 
1520
        self.assertFinished(client)
1517
1521
 
1518
1522
    def test_backwards_compat_set_option(self):
1519
1523
        self.setup_smart_server_with_call_log()
1543
1547
        transport = transport.clone('quack')
1544
1548
        branch = self.make_remote_branch(transport, client)
1545
1549
        self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1546
 
        client.finished_test()
 
1550
        self.assertFinished(client)
1547
1551
 
1548
1552
 
1549
1553
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
2045
2049
            'success', ('ok', 'rev-five'))
2046
2050
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2047
2051
        self.assertEqual((True, 'rev-five'), result)
2048
 
        client.finished_test()
 
2052
        self.assertFinished(client)
2049
2053
 
2050
2054
    def test_history_incomplete(self):
2051
2055
        repo, client = self.setup_fake_client_and_repository('quack')
2054
2058
            'success', ('history-incomplete', 10, 'rev-ten'))
2055
2059
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2056
2060
        self.assertEqual((False, (10, 'rev-ten')), result)
2057
 
        client.finished_test()
 
2061
        self.assertFinished(client)
2058
2062
 
2059
2063
    def test_history_incomplete_with_fallback(self):
2060
2064
        """A 'history-incomplete' response causes the fallback repository to be
2080
2084
            'success', ('ok', 'rev-one'))
2081
2085
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2082
2086
        self.assertEqual((True, 'rev-one'), result)
2083
 
        client.finished_test()
 
2087
        self.assertFinished(client)
2084
2088
 
2085
2089
    def test_nosuchrevision(self):
2086
2090
        # 'nosuchrevision' is returned when the known-revid is not found in the
2092
2096
        self.assertRaises(
2093
2097
            errors.NoSuchRevision,
2094
2098
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2095
 
        client.finished_test()
 
2099
        self.assertFinished(client)
2096
2100
 
2097
2101
 
2098
2102
class TestRepositoryIsShared(TestRemoteRepository):
2231
2235
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2232
2236
        self.assertEqual([], resume_tokens)
2233
2237
        self.assertEqual(set(), missing_keys)
2234
 
        client.finished_test()
 
2238
        self.assertFinished(client)
2235
2239
 
2236
2240
    def test_locked_repo_with_no_lock_token(self):
2237
2241
        transport_path = 'quack'
2251
2255
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2252
2256
        self.assertEqual([], resume_tokens)
2253
2257
        self.assertEqual(set(), missing_keys)
2254
 
        client.finished_test()
 
2258
        self.assertFinished(client)
2255
2259
 
2256
2260
    def test_locked_repo_with_lock_token(self):
2257
2261
        transport_path = 'quack'
2271
2275
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2272
2276
        self.assertEqual([], resume_tokens)
2273
2277
        self.assertEqual(set(), missing_keys)
2274
 
        client.finished_test()
 
2278
        self.assertFinished(client)
2275
2279
 
2276
2280
 
2277
2281
class TestRepositoryTarball(TestRemoteRepository):
2362
2366
        client.add_expected_call(
2363
2367
            'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2364
2368
        repo.autopack()
2365
 
        client.finished_test()
 
2369
        self.assertFinished(client)
2366
2370
 
2367
2371
    def test_ok_with_real_repo(self):
2368
2372
        """When the server returns 'ok' and there is a _real_repository, then