← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_serve.py

Factor out _type_equality_funcs to a new function

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
25
25
 
26
26
from bzrlib import (
27
27
    builtins,
28
 
    config,
29
28
    errors,
30
29
    osutils,
31
30
    revision as _mod_revision,
67
66
            try:
68
67
                # Run func if set
69
68
                self.tcp_server = tcp_server
70
 
                if func is not None:
 
69
                if not func is None:
71
70
                    try:
72
71
                        func(*func_args, **func_kwargs)
73
72
                    except Exception, e:
88
87
        SmartTCPServer.hooks.install_named_hook(
89
88
            'server_started_ex', on_server_start,
90
89
            'run_bzr_serve_then_func hook')
91
 
        # It seesm thread.interrupt_main() will not raise KeyboardInterrupt
92
 
        # until after socket.accept returns. So we set the timeout low to make
93
 
        # the test faster.
94
 
        self.overrideAttr(SmartTCPServer, '_ACCEPT_TIMEOUT', 0.1)
95
90
        # start a TCP server
96
91
        try:
97
92
            out, err = self.run_bzr(['serve'] + list(serve_args),
271
266
        f.close()
272
267
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
273
268
 
274
 
    def test_bzr_serve_supports_configurable_timeout(self):
275
 
        gs = config.GlobalStack()
276
 
        gs.set('serve.client_timeout', 0.2)
277
 
        process, url = self.start_server_port()
278
 
        self.build_tree_contents([('a_file', 'contents\n')])
279
 
        # We can connect and issue a request
280
 
        t = transport.get_transport_from_url(url)
281
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
282
 
        # However, if we just wait for more content from the server, it will
283
 
        # eventually disconnect us.
284
 
        # TODO: Use something like signal.alarm() so that if the server doesn't
285
 
        #       properly handle the timeout, we end up failing the test instead
286
 
        #       of hanging forever.
287
 
        m = t.get_smart_medium()
288
 
        m.read_bytes(1)
289
 
        # Now, we wait for timeout to trigger
290
 
        err = process.stderr.readline()
291
 
        self.assertEqual(
292
 
            'Connection Timeout: disconnecting client after 0.2 seconds\n',
293
 
            err)
294
 
        self.assertServerFinishesCleanly(process)
295
 
 
296
 
    def test_bzr_serve_supports_client_timeout(self):
297
 
        process, url = self.start_server_port(['--client-timeout=0.1'])
298
 
        self.build_tree_contents([('a_file', 'contents\n')])
299
 
        # We can connect and issue a request
300
 
        t = transport.get_transport_from_url(url)
301
 
        self.assertEqual('contents\n', t.get_bytes('a_file'))
302
 
        # However, if we just wait for more content from the server, it will
303
 
        # eventually disconnect us.
304
 
        # TODO: Use something like signal.alarm() so that if the server doesn't
305
 
        #       properly handle the timeout, we end up failing the test instead
306
 
        #       of hanging forever.
307
 
        m = t.get_smart_medium()
308
 
        m.read_bytes(1)
309
 
        # Now, we wait for timeout to trigger
310
 
        err = process.stderr.readline()
311
 
        self.assertEqual(
312
 
            'Connection Timeout: disconnecting client after 0.1 seconds\n',
313
 
            err)
314
 
        self.assertServerFinishesCleanly(process)
315
 
 
316
 
    def test_bzr_serve_graceful_shutdown(self):
317
 
        big_contents = 'a'*64*1024
318
 
        self.build_tree_contents([('bigfile', big_contents)])
319
 
        process, url = self.start_server_port(['--client-timeout=1.0'])
320
 
        t = transport.get_transport_from_url(url)
321
 
        m = t.get_smart_medium()
322
 
        c = client._SmartClient(m)
323
 
        # Start, but don't finish a response
324
 
        resp, response_handler = c.call_expecting_body('get', 'bigfile')
325
 
        self.assertEqual(('ok',), resp)
326
 
        # Note: process.send_signal is a Python 2.6ism
327
 
        process.send_signal(signal.SIGHUP)
328
 
        # Wait for the server to notice the signal, and then read the actual
329
 
        # body of the response. That way we know that it is waiting for the
330
 
        # request to finish
331
 
        self.assertEqual('Requested to stop gracefully\n',
332
 
                         process.stderr.readline())
333
 
        self.assertEqual('Waiting for 1 client(s) to finish\n',
334
 
                         process.stderr.readline())
335
 
        body = response_handler.read_body_bytes()
336
 
        if body != big_contents:
337
 
            self.fail('Failed to properly read the contents of "bigfile"')
338
 
        # Now that our request is finished, the medium should notice it has
339
 
        # been disconnected.
340
 
        self.assertEqual('', m.read_bytes(1))
341
 
        # And the server should be stopping
342
 
        self.assertEqual(0, process.wait())
343
 
 
344
269
 
345
270
class TestCmdServeChrooting(TestBzrServeBase):
346
271
 
402
327
            self.fake_expanduser, lambda t: base_path)
403
328
        mem_transport = self.get_transport()
404
329
        mem_transport.mkdir_multi(['home', 'home/user'])
405
 
        bzr_server.set_up(mem_transport, None, None, inet=True, timeout=4.0)
 
330
        bzr_server.set_up(mem_transport, None, None, inet=True)
406
331
        self.addCleanup(bzr_server.tear_down)
407
332
        return bzr_server
408
333
 
424
349
        base_url = urlutils.local_path_to_url(base_dir) + '/'
425
350
        # Define a fake 'protocol' to capture the transport that cmd_serve
426
351
        # passes to serve_bzr.
427
 
        def capture_transport(transport, host, port, inet, timeout):
 
352
        def capture_transport(transport, host, port, inet):
428
353
            self.bzr_serve_transport = transport
429
354
        cmd = builtins.cmd_serve()
430
355
        # Read-only
441
366
        self.assertEqual(base_url, self.bzr_serve_transport.base)
442
367
        self.assertEqual(base_dir,
443
368
            server_maker.get_base_path(self.bzr_serve_transport))
444
 
        # Read-only, from a URL
445
 
        cmd.run(directory=base_url, protocol=capture_transport)
446
 
        server_maker = BzrServerFactory()
447
 
        self.assertEqual(
448
 
            'readonly+%s' % base_url, self.bzr_serve_transport.base)
449
 
        self.assertEqual(
450
 
            base_dir, server_maker.get_base_path(self.bzr_serve_transport))