/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_smart_transport.py

  • Committer: Andrew Bennetts
  • Date: 2008-05-19 06:58:44 UTC
  • mto: This revision was merged to the branch mainline in revision 3439.
  • Revision ID: andrew.bennetts@canonical.com-20080519065844-i9euu4oebe5796d0
First rough cut of a fix for bug #230550, by adding .base to SmartClientMedia rather than relying on other objects to track this accurately while reusing client media.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
115
115
        sock.bind(('127.0.0.1', 0))
116
116
        sock.listen(1)
117
117
        port = sock.getsockname()[1]
118
 
        client_medium = medium.SmartTCPClientMedium('127.0.0.1', port)
 
118
        client_medium = medium.SmartTCPClientMedium('127.0.0.1', port, 'base')
119
119
        return sock, client_medium
120
120
 
121
121
    def receive_bytes_on_server(self, sock, bytes):
149
149
        # readable pipe, writeable pipe.
150
150
        # Constructing one should just save these and do nothing.
151
151
        # We test this by passing in None.
152
 
        client_medium = medium.SmartSimplePipesClientMedium(None, None)
 
152
        client_medium = medium.SmartSimplePipesClientMedium(None, None, None)
153
153
        
154
154
    def test_simple_pipes_client_request_type(self):
155
155
        # SimplePipesClient should use SmartClientStreamMediumRequest's.
156
 
        client_medium = medium.SmartSimplePipesClientMedium(None, None)
 
156
        client_medium = medium.SmartSimplePipesClientMedium(None, None, None)
157
157
        request = client_medium.get_request()
158
158
        self.assertIsInstance(request, medium.SmartClientStreamMediumRequest)
159
159
 
165
165
        # classes - as the sibling classes share this logic, they do not have
166
166
        # explicit tests for this.
167
167
        output = StringIO()
168
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
168
        client_medium = medium.SmartSimplePipesClientMedium(
 
169
            None, output, 'base')
169
170
        request = client_medium.get_request()
170
171
        request.finished_writing()
171
172
        request.finished_reading()
176
177
    def test_simple_pipes_client__accept_bytes_writes_to_writable(self):
177
178
        # accept_bytes writes to the writeable pipe.
178
179
        output = StringIO()
179
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
180
        client_medium = medium.SmartSimplePipesClientMedium(
 
181
            None, output, 'base')
180
182
        client_medium._accept_bytes('abc')
181
183
        self.assertEqual('abc', output.getvalue())
182
184
    
184
186
        # calling disconnect does nothing.
185
187
        input = StringIO()
186
188
        output = StringIO()
187
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
189
        client_medium = medium.SmartSimplePipesClientMedium(
 
190
            input, output, 'base')
188
191
        # send some bytes to ensure disconnecting after activity still does not
189
192
        # close.
190
193
        client_medium._accept_bytes('abc')
197
200
        # accept_bytes writes to.
198
201
        input = StringIO()
199
202
        output = StringIO()
200
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
203
        client_medium = medium.SmartSimplePipesClientMedium(
 
204
            input, output, 'base')
201
205
        client_medium._accept_bytes('abc')
202
206
        client_medium.disconnect()
203
207
        client_medium._accept_bytes('abc')
208
212
    def test_simple_pipes_client_ignores_disconnect_when_not_connected(self):
209
213
        # Doing a disconnect on a new (and thus unconnected) SimplePipes medium
210
214
        # does nothing.
211
 
        client_medium = medium.SmartSimplePipesClientMedium(None, None)
 
215
        client_medium = medium.SmartSimplePipesClientMedium(None, None, 'base')
212
216
        client_medium.disconnect()
213
217
 
214
218
    def test_simple_pipes_client_can_always_read(self):
215
219
        # SmartSimplePipesClientMedium is never disconnected, so read_bytes
216
220
        # always tries to read from the underlying pipe.
217
221
        input = StringIO('abcdef')
218
 
        client_medium = medium.SmartSimplePipesClientMedium(input, None)
 
222
        client_medium = medium.SmartSimplePipesClientMedium(input, None, 'base')
219
223
        self.assertEqual('abc', client_medium.read_bytes(3))
220
224
        client_medium.disconnect()
221
225
        self.assertEqual('def', client_medium.read_bytes(3))
230
234
        flush_calls = []
231
235
        def logging_flush(): flush_calls.append('flush')
232
236
        output.flush = logging_flush
233
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
237
        client_medium = medium.SmartSimplePipesClientMedium(
 
238
            input, output, 'base')
234
239
        # this call is here to ensure we only flush once, not on every
235
240
        # _accept_bytes call.
236
241
        client_medium._accept_bytes('abc')
250
255
        # having vendor be invalid means that if it tries to connect via the
251
256
        # vendor it will blow up.
252
257
        client_medium = medium.SmartSSHClientMedium('127.0.0.1', unopened_port,
253
 
            username=None, password=None, vendor="not a vendor",
 
258
            username=None, password=None, base='base', vendor="not a vendor",
254
259
            bzr_remote_path='bzr')
255
260
        sock.close()
256
261
 
260
265
        output = StringIO()
261
266
        vendor = StringIOSSHVendor(StringIO(), output)
262
267
        client_medium = medium.SmartSSHClientMedium(
263
 
            'a hostname', 'a port', 'a username', 'a password', vendor, 'bzr')
 
268
            'a hostname', 'a port', 'a username', 'a password', 'base', vendor,
 
269
            'bzr')
264
270
        client_medium._accept_bytes('abc')
265
271
        self.assertEqual('abc', output.getvalue())
266
272
        self.assertEqual([('connect_ssh', 'a username', 'a password',
281
287
        client_medium = self.callDeprecated(
282
288
            ['bzr_remote_path is required as of bzr 0.92'],
283
289
            medium.SmartSSHClientMedium, 'a hostname', 'a port', 'a username',
284
 
            'a password', vendor)
 
290
            'a password', 'base', vendor)
285
291
        client_medium._accept_bytes('abc')
286
292
        self.assertEqual('abc', output.getvalue())
287
293
        self.assertEqual([('connect_ssh', 'a username', 'a password',
295
301
        output = StringIO()
296
302
        vendor = StringIOSSHVendor(StringIO(), output)
297
303
        client_medium = medium.SmartSSHClientMedium('a hostname', 'a port',
298
 
            'a username', 'a password', vendor, bzr_remote_path='fugly')
 
304
            'a username', 'a password', 'base', vendor, bzr_remote_path='fugly')
299
305
        client_medium._accept_bytes('abc')
300
306
        self.assertEqual('abc', output.getvalue())
301
307
        self.assertEqual([('connect_ssh', 'a username', 'a password',
309
315
        input = StringIO()
310
316
        output = StringIO()
311
317
        vendor = StringIOSSHVendor(input, output)
312
 
        client_medium = medium.SmartSSHClientMedium('a hostname',
313
 
                                                    vendor=vendor,
314
 
                                                    bzr_remote_path='bzr')
 
318
        client_medium = medium.SmartSSHClientMedium(
 
319
            'a hostname', base='base', vendor=vendor, bzr_remote_path='bzr')
315
320
        client_medium._accept_bytes('abc')
316
321
        client_medium.disconnect()
317
322
        self.assertTrue(input.closed)
331
336
        input = StringIO()
332
337
        output = StringIO()
333
338
        vendor = StringIOSSHVendor(input, output)
334
 
        client_medium = medium.SmartSSHClientMedium('a hostname',
335
 
            vendor=vendor, bzr_remote_path='bzr')
 
339
        client_medium = medium.SmartSSHClientMedium(
 
340
            'a hostname', base='base', vendor=vendor, bzr_remote_path='bzr')
336
341
        client_medium._accept_bytes('abc')
337
342
        client_medium.disconnect()
338
343
        # the disconnect has closed output, so we need a new output for the
360
365
    def test_ssh_client_ignores_disconnect_when_not_connected(self):
361
366
        # Doing a disconnect on a new (and thus unconnected) SSH medium
362
367
        # does not fail.  It's ok to disconnect an unconnected medium.
363
 
        client_medium = medium.SmartSSHClientMedium(None,
364
 
                                                    bzr_remote_path='bzr')
 
368
        client_medium = medium.SmartSSHClientMedium(
 
369
            None, base='base', bzr_remote_path='bzr')
365
370
        client_medium.disconnect()
366
371
 
367
372
    def test_ssh_client_raises_on_read_when_not_connected(self):
368
373
        # Doing a read on a new (and thus unconnected) SSH medium raises
369
374
        # MediumNotConnected.
370
 
        client_medium = medium.SmartSSHClientMedium(None,
371
 
                                                    bzr_remote_path='bzr')
 
375
        client_medium = medium.SmartSSHClientMedium(
 
376
            None, base='base', bzr_remote_path='bzr')
372
377
        self.assertRaises(errors.MediumNotConnected, client_medium.read_bytes,
373
378
                          0)
374
379
        self.assertRaises(errors.MediumNotConnected, client_medium.read_bytes,
385
390
        def logging_flush(): flush_calls.append('flush')
386
391
        output.flush = logging_flush
387
392
        vendor = StringIOSSHVendor(input, output)
388
 
        client_medium = medium.SmartSSHClientMedium('a hostname',
389
 
                                                    vendor=vendor,
390
 
                                                    bzr_remote_path='bzr')
 
393
        client_medium = medium.SmartSSHClientMedium(
 
394
            'a hostname', base='base', vendor=vendor, bzr_remote_path='bzr')
391
395
        # this call is here to ensure we only flush once, not on every
392
396
        # _accept_bytes call.
393
397
        client_medium._accept_bytes('abc')
401
405
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
402
406
        sock.bind(('127.0.0.1', 0))
403
407
        unopened_port = sock.getsockname()[1]
404
 
        client_medium = medium.SmartTCPClientMedium('127.0.0.1', unopened_port)
 
408
        client_medium = medium.SmartTCPClientMedium(
 
409
            '127.0.0.1', unopened_port, 'base')
405
410
        sock.close()
406
411
 
407
412
    def test_tcp_client_connects_on_first_use(self):
435
440
    def test_tcp_client_ignores_disconnect_when_not_connected(self):
436
441
        # Doing a disconnect on a new (and thus unconnected) TCP medium
437
442
        # does not fail.  It's ok to disconnect an unconnected medium.
438
 
        client_medium = medium.SmartTCPClientMedium(None, None)
 
443
        client_medium = medium.SmartTCPClientMedium(None, None, None)
439
444
        client_medium.disconnect()
440
445
 
441
446
    def test_tcp_client_raises_on_read_when_not_connected(self):
442
447
        # Doing a read on a new (and thus unconnected) TCP medium raises
443
448
        # MediumNotConnected.
444
 
        client_medium = medium.SmartTCPClientMedium(None, None)
 
449
        client_medium = medium.SmartTCPClientMedium(None, None, None)
445
450
        self.assertRaises(errors.MediumNotConnected, client_medium.read_bytes, 0)
446
451
        self.assertRaises(errors.MediumNotConnected, client_medium.read_bytes, 1)
447
452
 
467
472
    def test_tcp_client_host_unknown_connection_error(self):
468
473
        self.requireFeature(InvalidHostnameFeature)
469
474
        client_medium = medium.SmartTCPClientMedium(
470
 
            'non_existent.invalid', 4155)
 
475
            'non_existent.invalid', 4155, 'base')
471
476
        self.assertRaises(
472
477
            errors.ConnectionError, client_medium._ensure_connection)
473
478
 
485
490
        # WritingCompleted to prevent bad assumptions on stream environments
486
491
        # breaking the needs of message-based environments.
487
492
        output = StringIO()
488
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
493
        client_medium = medium.SmartSimplePipesClientMedium(
 
494
            None, output, 'base')
489
495
        request = medium.SmartClientStreamMediumRequest(client_medium)
490
496
        request.finished_writing()
491
497
        self.assertRaises(errors.WritingCompleted, request.accept_bytes, None)
496
502
        # and checking that the pipes get the data.
497
503
        input = StringIO()
498
504
        output = StringIO()
499
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
505
        client_medium = medium.SmartSimplePipesClientMedium(
 
506
            input, output, 'base')
500
507
        request = medium.SmartClientStreamMediumRequest(client_medium)
501
508
        request.accept_bytes('123')
502
509
        request.finished_writing()
508
515
        # constructing a SmartClientStreamMediumRequest on a StreamMedium sets
509
516
        # the current request to the new SmartClientStreamMediumRequest
510
517
        output = StringIO()
511
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
518
        client_medium = medium.SmartSimplePipesClientMedium(
 
519
            None, output, 'base')
512
520
        request = medium.SmartClientStreamMediumRequest(client_medium)
513
521
        self.assertIs(client_medium._current_request, request)
514
522
 
516
524
        # constructing a SmartClientStreamMediumRequest on a StreamMedium with
517
525
        # a non-None _current_request raises TooManyConcurrentRequests.
518
526
        output = StringIO()
519
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
527
        client_medium = medium.SmartSimplePipesClientMedium(
 
528
            None, output, 'base')
520
529
        client_medium._current_request = "a"
521
530
        self.assertRaises(errors.TooManyConcurrentRequests,
522
531
            medium.SmartClientStreamMediumRequest, client_medium)
525
534
        # calling finished_reading clears the current request from the requests
526
535
        # medium
527
536
        output = StringIO()
528
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
537
        client_medium = medium.SmartSimplePipesClientMedium(
 
538
            None, output, 'base')
529
539
        request = medium.SmartClientStreamMediumRequest(client_medium)
530
540
        request.finished_writing()
531
541
        request.finished_reading()
534
544
    def test_finished_read_before_finished_write_errors(self):
535
545
        # calling finished_reading before calling finished_writing triggers a
536
546
        # WritingNotComplete error.
537
 
        client_medium = medium.SmartSimplePipesClientMedium(None, None)
 
547
        client_medium = medium.SmartSimplePipesClientMedium(
 
548
            None, None, 'base')
538
549
        request = medium.SmartClientStreamMediumRequest(client_medium)
539
550
        self.assertRaises(errors.WritingNotComplete, request.finished_reading)
540
551
        
547
558
        # smoke tests.
548
559
        input = StringIO('321')
549
560
        output = StringIO()
550
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
561
        client_medium = medium.SmartSimplePipesClientMedium(
 
562
            input, output, 'base')
551
563
        request = medium.SmartClientStreamMediumRequest(client_medium)
552
564
        request.finished_writing()
553
565
        self.assertEqual('321', request.read_bytes(3))
560
572
        # WritingNotComplete error because the Smart protocol is designed to be
561
573
        # compatible with strict message based protocols like HTTP where the
562
574
        # request cannot be submitted until the writing has completed.
563
 
        client_medium = medium.SmartSimplePipesClientMedium(None, None)
 
575
        client_medium = medium.SmartSimplePipesClientMedium(None, None, 'base')
564
576
        request = medium.SmartClientStreamMediumRequest(client_medium)
565
577
        self.assertRaises(errors.WritingNotComplete, request.read_bytes, None)
566
578
 
569
581
        # ReadingCompleted to prevent bad assumptions on stream environments
570
582
        # breaking the needs of message-based environments.
571
583
        output = StringIO()
572
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
584
        client_medium = medium.SmartSimplePipesClientMedium(
 
585
            None, output, 'base')
573
586
        request = medium.SmartClientStreamMediumRequest(client_medium)
574
587
        request.finished_writing()
575
588
        request.finished_reading()
1372
1385
        # We want to be able to pass a client as a parameter to RemoteTransport.
1373
1386
        input = StringIO('ok\n3\nbardone\n')
1374
1387
        output = StringIO()
1375
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1388
        client_medium = medium.SmartSimplePipesClientMedium(
 
1389
            input, output, 'base')
1376
1390
        transport = remote.RemoteTransport(
1377
1391
            'bzr://localhost/', medium=client_medium)
1378
1392
        # Disable version detection.
1394
1408
 
1395
1409
    def test__translate_error_readonly(self):
1396
1410
        """Sending a ReadOnlyError to _translate_error raises TransportNotPossible."""
1397
 
        client_medium = medium.SmartClientMedium()
 
1411
        client_medium = medium.SmartSimplePipesClientMedium(None, None, 'base')
1398
1412
        transport = remote.RemoteTransport(
1399
1413
            'bzr://localhost/', medium=client_medium)
1400
1414
        self.assertRaises(errors.TransportNotPossible,
1433
1447
        else:
1434
1448
            input = StringIO(input_bytes)
1435
1449
        output = StringIO()
1436
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1450
        client_medium = medium.SmartSimplePipesClientMedium(
 
1451
            input, output, 'base')
1437
1452
        request = client_medium.get_request()
1438
1453
        if self.client_protocol_class is not None:
1439
1454
            client_protocol = self.client_protocol_class(request)
1566
1581
    def test_construct_version_one_client_protocol(self):
1567
1582
        # we can construct a client protocol from a client medium request
1568
1583
        output = StringIO()
1569
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
1584
        client_medium = medium.SmartSimplePipesClientMedium(
 
1585
            None, output, 'base')
1570
1586
        request = client_medium.get_request()
1571
1587
        client_protocol = protocol.SmartClientRequestProtocolOne(request)
1572
1588
 
1664
1680
        # the error if the response is a non-understood version.
1665
1681
        input = StringIO('ok\x012\n')
1666
1682
        output = StringIO()
1667
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1683
        client_medium = medium.SmartSimplePipesClientMedium(
 
1684
            input, output, 'base')
1668
1685
        request = client_medium.get_request()
1669
1686
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1670
1687
        self.assertEqual(2, smart_protocol.query_version())
1687
1704
        expected_bytes = "foo\n7\nabcdefgdone\n"
1688
1705
        input = StringIO("\n")
1689
1706
        output = StringIO()
1690
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1707
        client_medium = medium.SmartSimplePipesClientMedium(
 
1708
            input, output, 'base')
1691
1709
        request = client_medium.get_request()
1692
1710
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1693
1711
        smart_protocol.call_with_body_bytes(('foo', ), "abcdefg")
1699
1717
        expected_bytes = "foo\n7\n1,2\n5,6done\n"
1700
1718
        input = StringIO("\n")
1701
1719
        output = StringIO()
1702
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1720
        client_medium = medium.SmartSimplePipesClientMedium(
 
1721
            input, output, 'base')
1703
1722
        request = client_medium.get_request()
1704
1723
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1705
1724
        smart_protocol.call_with_body_readv_array(('foo', ), [(1,2),(5,6)])
1709
1728
            server_bytes):
1710
1729
        input = StringIO(server_bytes)
1711
1730
        output = StringIO()
1712
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1731
        client_medium = medium.SmartSimplePipesClientMedium(
 
1732
            input, output, 'base')
1713
1733
        request = client_medium.get_request()
1714
1734
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1715
1735
        smart_protocol.call('foo')
1747
1767
        server_bytes = "ok\n7\n1234567done\n"
1748
1768
        input = StringIO(server_bytes)
1749
1769
        output = StringIO()
1750
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1770
        client_medium = medium.SmartSimplePipesClientMedium(
 
1771
            input, output, 'base')
1751
1772
        request = client_medium.get_request()
1752
1773
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1753
1774
        smart_protocol.call('foo')
1764
1785
        server_bytes = "ok\n7\n1234567done\n"
1765
1786
        input = StringIO(server_bytes)
1766
1787
        output = StringIO()
1767
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1788
        client_medium = medium.SmartSimplePipesClientMedium(
 
1789
            input, output, 'base')
1768
1790
        request = client_medium.get_request()
1769
1791
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1770
1792
        smart_protocol.call('foo')
1781
1803
        server_bytes = "ok\n7\n1234567done\n"
1782
1804
        input = StringIO(server_bytes)
1783
1805
        output = StringIO()
1784
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1806
        client_medium = medium.SmartSimplePipesClientMedium(
 
1807
            input, output, 'base')
1785
1808
        request = client_medium.get_request()
1786
1809
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
1787
1810
        smart_protocol.call('foo')
1811
1834
    def test_construct_version_two_client_protocol(self):
1812
1835
        # we can construct a client protocol from a client medium request
1813
1836
        output = StringIO()
1814
 
        client_medium = medium.SmartSimplePipesClientMedium(None, output)
 
1837
        client_medium = medium.SmartSimplePipesClientMedium(
 
1838
            None, output, 'base')
1815
1839
        request = client_medium.get_request()
1816
1840
        client_protocol = protocol.SmartClientRequestProtocolTwo(request)
1817
1841
 
1914
1938
        # the error if the response is a non-understood version.
1915
1939
        input = StringIO(self.response_marker + 'success\nok\x012\n')
1916
1940
        output = StringIO()
1917
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1941
        client_medium = medium.SmartSimplePipesClientMedium(
 
1942
            input, output, 'base')
1918
1943
        request = client_medium.get_request()
1919
1944
        smart_protocol = self.client_protocol_class(request)
1920
1945
        self.assertEqual(2, smart_protocol.query_version())
1940
1965
        expected_bytes = self.request_marker + "foo\n7\nabcdefgdone\n"
1941
1966
        input = StringIO("\n")
1942
1967
        output = StringIO()
1943
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1968
        client_medium = medium.SmartSimplePipesClientMedium(
 
1969
            input, output, 'base')
1944
1970
        request = client_medium.get_request()
1945
1971
        smart_protocol = self.client_protocol_class(request)
1946
1972
        smart_protocol.call_with_body_bytes(('foo', ), "abcdefg")
1952
1978
        expected_bytes = self.request_marker + "foo\n7\n1,2\n5,6done\n"
1953
1979
        input = StringIO("\n")
1954
1980
        output = StringIO()
1955
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1981
        client_medium = medium.SmartSimplePipesClientMedium(
 
1982
            input, output, 'base')
1956
1983
        request = client_medium.get_request()
1957
1984
        smart_protocol = self.client_protocol_class(request)
1958
1985
        smart_protocol.call_with_body_readv_array(('foo', ), [(1,2),(5,6)])
1966
1993
                        "success\nok\n7\n1234567done\n")
1967
1994
        input = StringIO(server_bytes)
1968
1995
        output = StringIO()
1969
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
1996
        client_medium = medium.SmartSimplePipesClientMedium(
 
1997
            input, output, 'base')
1970
1998
        request = client_medium.get_request()
1971
1999
        smart_protocol = self.client_protocol_class(request)
1972
2000
        smart_protocol.call('foo')
1983
2011
        server_bytes = self.response_marker + "success\nok\n7\n1234567done\n"
1984
2012
        input = StringIO(server_bytes)
1985
2013
        output = StringIO()
1986
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2014
        client_medium = medium.SmartSimplePipesClientMedium(
 
2015
            input, output, 'base')
1987
2016
        request = client_medium.get_request()
1988
2017
        smart_protocol = self.client_protocol_class(request)
1989
2018
        smart_protocol.call('foo')
1999
2028
        server_bytes = self.response_marker + "success\nok\n7\n1234567done\n"
2000
2029
        input = StringIO(server_bytes)
2001
2030
        output = StringIO()
2002
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2031
        client_medium = medium.SmartSimplePipesClientMedium(
 
2032
            input, output, 'base')
2003
2033
        request = client_medium.get_request()
2004
2034
        smart_protocol = self.client_protocol_class(request)
2005
2035
        smart_protocol.call('foo')
2102
2132
                        body_terminator)
2103
2133
        input = StringIO(server_bytes)
2104
2134
        output = StringIO()
2105
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2135
        client_medium = medium.SmartSimplePipesClientMedium(
 
2136
            input, output, 'base')
2106
2137
        request = client_medium.get_request()
2107
2138
        smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
2108
2139
        smart_protocol.call('foo')
2122
2153
                        "success\nok\n" + body)
2123
2154
        input = StringIO(server_bytes)
2124
2155
        output = StringIO()
2125
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2156
        client_medium = medium.SmartSimplePipesClientMedium(
 
2157
            input, output, 'base')
2126
2158
        smart_request = client_medium.get_request()
2127
2159
        smart_protocol = protocol.SmartClientRequestProtocolTwo(smart_request)
2128
2160
        smart_protocol.call('foo')
2137
2169
        server_bytes = protocol.RESPONSE_VERSION_TWO + "success\nok\n"
2138
2170
        input = StringIO(server_bytes)
2139
2171
        output = StringIO()
2140
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2172
        client_medium = medium.SmartSimplePipesClientMedium(
 
2173
            input, output, 'base')
2141
2174
        request = client_medium.get_request()
2142
2175
        smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
2143
2176
        smart_protocol.call('foo')
2154
2187
            "error\x01Generic bzr smart protocol error: bad request 'foo'\n")
2155
2188
        input = StringIO(server_bytes)
2156
2189
        output = StringIO()
2157
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2190
        client_medium = medium.SmartSimplePipesClientMedium(
 
2191
            input, output, 'base')
2158
2192
        request = client_medium.get_request()
2159
2193
        smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
2160
2194
        smart_protocol.call('foo')
2332
2366
        protocol_decoder.state_accept = protocol_decoder._state_accept_expecting_message_part
2333
2367
        output = StringIO()
2334
2368
        client_medium = medium.SmartSimplePipesClientMedium(
2335
 
            StringIO(interrupted_body_stream), output)
 
2369
            StringIO(interrupted_body_stream), output, 'base')
2336
2370
        medium_request = client_medium.get_request()
2337
2371
        medium_request.finished_writing()
2338
2372
        response_handler.setProtoAndMediumRequest(
2585
2619
        """
2586
2620
        input = StringIO("\n")
2587
2621
        output = StringIO()
2588
 
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
 
2622
        client_medium = medium.SmartSimplePipesClientMedium(
 
2623
            input, output, 'ignored base')
2589
2624
        smart_client = client._SmartClient(client_medium, 'ignored base')
2590
2625
        self.assertRaises(TypeError,
2591
2626
            smart_client.call_with_body_bytes, method, args, body)
2827
2862
        """ProtocolThreeRequester.call by default sends a 'Software
2828
2863
        version' header.
2829
2864
        """
2830
 
        smart_client = client._SmartClient(medium, 'base')
 
2865
        class DummyMedium(object):
 
2866
            base = 'base'
 
2867
        smart_client = client._SmartClient(DummyMedium(), 'base')
2831
2868
        self.assertEqual(
2832
2869
            bzrlib.__version__, smart_client._headers['Software version'])
2833
2870
        # XXX: need a test that smart_client._headers is passed to the request