← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart_transport.py

Merge lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
732
732
        client_sock.sendall(rest_of_request_bytes)
733
733
        server._serve_one_request(server_protocol)
734
734
        server_sock.close()
735
 
        self.assertEqual(expected_response, client_sock.recv(50),
 
735
        self.assertEqual(expected_response, osutils.recv_all(client_sock, 50),
736
736
                         "Not a version 2 response to 'hello' request.")
737
737
        self.assertEqual('', client_sock.recv(1))
738
738
 
993
993
 
994
994
        :param readonly: Create a readonly server.
995
995
        """
 
996
        # NB: Tests using this fall into two categories: tests of the server,
 
997
        # tests wanting a server. The latter should be updated to use
 
998
        # self.vfs_transport_factory etc.
996
999
        if not backing_transport:
997
 
            self.backing_transport = memory.MemoryTransport()
 
1000
            mem_server = memory.MemoryServer()
 
1001
            mem_server.setUp()
 
1002
            self.addCleanup(mem_server.tearDown)
 
1003
            self.permit_url(mem_server.get_url())
 
1004
            self.backing_transport = get_transport(mem_server.get_url())
998
1005
        else:
999
1006
            self.backing_transport = backing_transport
1000
1007
        if readonly:
1004
1011
        self.server.start_background_thread('-' + self.id())
1005
1012
        self.transport = remote.RemoteTCPTransport(self.server.get_url())
1006
1013
        self.addCleanup(self.tearDownServer)
 
1014
        self.permit_url(self.server.get_url())
1007
1015
 
1008
1016
    def tearDownServer(self):
1009
1017
        if getattr(self, 'transport', None):
1248
1256
 
1249
1257
    def test_hello(self):
1250
1258
        handler = self.build_handler(None)
1251
 
        handler.dispatch_command('hello', ())
 
1259
        handler.args_received(('hello',))
1252
1260
        self.assertEqual(('ok', '2'), handler.response.args)
1253
1261
        self.assertEqual(None, handler.response.body)
1254
1262
 
1268
1276
        """The response for a read-only error is ('ReadOnlyError')."""
1269
1277
        handler = self.build_handler(self.get_readonly_transport())
1270
1278
        # send a mkdir for foo, with no explicit mode - should fail.
1271
 
        handler.dispatch_command('mkdir', ('foo', ''))
 
1279
        handler.args_received(('mkdir', 'foo', ''))
1272
1280
        # and the failure should be an explicit ReadOnlyError
1273
1281
        self.assertEqual(("ReadOnlyError", ), handler.response.args)
1274
1282
        # XXX: TODO: test that other TransportNotPossible errors are
1279
1287
    def test_hello_has_finished_body_on_dispatch(self):
1280
1288
        """The 'hello' command should set finished_reading."""
1281
1289
        handler = self.build_handler(None)
1282
 
        handler.dispatch_command('hello', ())
 
1290
        handler.args_received(('hello',))
1283
1291
        self.assertTrue(handler.finished_reading)
1284
1292
        self.assertNotEqual(None, handler.response)
1285
1293
 
1286
1294
    def test_put_bytes_non_atomic(self):
1287
1295
        """'put_...' should set finished_reading after reading the bytes."""
1288
1296
        handler = self.build_handler(self.get_transport())
1289
 
        handler.dispatch_command('put_non_atomic', ('a-file', '', 'F', ''))
 
1297
        handler.args_received(('put_non_atomic', 'a-file', '', 'F', ''))
1290
1298
        self.assertFalse(handler.finished_reading)
1291
1299
        handler.accept_body('1234')
1292
1300
        self.assertFalse(handler.finished_reading)
1300
1308
        """'readv' should set finished_reading after reading offsets."""
1301
1309
        self.build_tree(['a-file'])
1302
1310
        handler = self.build_handler(self.get_readonly_transport())
1303
 
        handler.dispatch_command('readv', ('a-file', ))
 
1311
        handler.args_received(('readv', 'a-file'))
1304
1312
        self.assertFalse(handler.finished_reading)
1305
1313
        handler.accept_body('2,')
1306
1314
        self.assertFalse(handler.finished_reading)
1315
1323
        """'readv' when a short read occurs sets the response appropriately."""
1316
1324
        self.build_tree(['a-file'])
1317
1325
        handler = self.build_handler(self.get_readonly_transport())
1318
 
        handler.dispatch_command('readv', ('a-file', ))
 
1326
        handler.args_received(('readv', 'a-file'))
1319
1327
        # read beyond the end of the file.
1320
1328
        handler.accept_body('100,1')
1321
1329
        handler.end_of_body()
2542
2550
        self.calls.append(('end_received',))
2543
2551
        self.finished_reading = True
2544
2552
 
2545
 
    def dispatch_command(self, cmd, args):
2546
 
        self.calls.append(('dispatch_command', cmd, args))
 
2553
    def args_received(self, args):
 
2554
        self.calls.append(('args_received', args))
2547
2555
 
2548
2556
    def accept_body(self, bytes):
2549
2557
        self.calls.append(('accept_body', bytes))