← 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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-12-09 02:53:42 UTC
  • mfrom: (4873.2.3 2.1.0b4-win32-test-imports)
  • Revision ID: pqm@pqm.ubuntu.com-20091209025342-sidvxfcqdgxmuz59
(jam) Get the test suite running again on Windows, (bug #492561)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
"""Tests of the bzr serve command."""
19
19
 
20
20
import os
 
21
import os.path
21
22
import signal
 
23
import subprocess
22
24
import sys
23
25
import thread
24
26
import threading
28
30
    errors,
29
31
    osutils,
30
32
    revision as _mod_revision,
31
 
    trace,
32
 
    transport,
33
33
    urlutils,
34
34
    )
35
35
from bzrlib.branch import Branch
36
36
from bzrlib.bzrdir import BzrDir
37
37
from bzrlib.smart import client, medium
38
 
from bzrlib.smart.server import (
39
 
    BzrServerFactory,
40
 
    SmartTCPServer,
41
 
    )
 
38
from bzrlib.smart.server import BzrServerFactory, SmartTCPServer
42
39
from bzrlib.tests import (
 
40
    ParamikoFeature,
43
41
    TestCaseWithMemoryTransport,
44
42
    TestCaseWithTransport,
 
43
    TestSkipped,
45
44
    )
46
 
from bzrlib.transport import remote
47
 
 
 
45
from bzrlib.trace import mutter
 
46
from bzrlib.transport import get_transport, remote
48
47
 
49
48
class TestBzrServeBase(TestCaseWithTransport):
50
49
 
52
51
                                *func_args, **func_kwargs):
53
52
        """Run 'bzr serve', and run the given func in a thread once the server
54
53
        has started.
55
 
 
 
54
        
56
55
        When 'func' terminates, the server will be terminated too.
57
 
 
 
56
        
58
57
        Returns stdout and stderr.
59
58
        """
 
59
        # install hook
 
60
        def on_server_start(backing_urls, tcp_server):
 
61
            t = threading.Thread(
 
62
                target=on_server_start_thread, args=(tcp_server,))
 
63
            t.start()
60
64
        def on_server_start_thread(tcp_server):
61
 
            """This runs concurrently with the server thread.
62
 
 
63
 
            The server is interrupted as soon as ``func`` finishes, even if an
64
 
            exception is encountered.
65
 
            """
66
65
            try:
67
66
                # Run func if set
68
67
                self.tcp_server = tcp_server
72
71
                    except Exception, e:
73
72
                        # Log errors to make some test failures a little less
74
73
                        # mysterious.
75
 
                        trace.mutter('func broke: %r', e)
 
74
                        mutter('func broke: %r', e)
76
75
            finally:
77
76
                # Then stop the server
78
 
                trace.mutter('interrupting...')
 
77
                mutter('interrupting...')
79
78
                thread.interrupt_main()
80
 
        # When the hook is fired, it just starts ``on_server_start_thread`` and
81
 
        # return
82
 
        def on_server_start(backing_urls, tcp_server):
83
 
            t = threading.Thread(
84
 
                target=on_server_start_thread, args=(tcp_server,))
85
 
            t.start()
86
 
        # install hook
87
79
        SmartTCPServer.hooks.install_named_hook(
88
80
            'server_started_ex', on_server_start,
89
81
            'run_bzr_serve_then_func hook')
90
82
        # start a TCP server
91
83
        try:
92
 
            out, err = self.run_bzr(['serve'] + list(serve_args),
93
 
                                    retcode=retcode)
 
84
            out, err = self.run_bzr(['serve'] + list(serve_args))
94
85
        except KeyboardInterrupt, e:
95
86
            out, err = e.args
96
87
        return out, err
102
93
        super(TestBzrServe, self).setUp()
103
94
        self.disable_missing_extensions_warning()
104
95
 
105
 
    def test_server_exception_with_hook(self):
106
 
        """Catch exception from the server in the server_exception hook.
107
 
 
108
 
        We use ``run_bzr_serve_then_func`` without a ``func`` so the server
109
 
        will receive a KeyboardInterrupt exception we want to catch.
110
 
        """
111
 
        def hook(exception):
112
 
            if exception[0] is KeyboardInterrupt:
113
 
                sys.stderr.write('catching KeyboardInterrupt\n')
114
 
                return True
115
 
            else:
116
 
                return False
117
 
        SmartTCPServer.hooks.install_named_hook(
118
 
            'server_exception', hook,
119
 
            'test_server_except_hook hook')
120
 
        args = ['--port', 'localhost:0', '--quiet']
121
 
        out, err = self.run_bzr_serve_then_func(args, retcode=0)
122
 
        self.assertEqual('catching KeyboardInterrupt\n', err)
123
 
 
124
 
    def test_server_exception_no_hook(self):
125
 
        """test exception without hook returns error"""
126
 
        args = []
127
 
        out, err = self.run_bzr_serve_then_func(args, retcode=3)
128
 
 
129
96
    def assertInetServerShutsdownCleanly(self, process):
130
97
        """Shutdown the server process looking for errors."""
131
98
        # Shutdown the server: the server should shut down when it cannot read
163
130
            finish_bzr_subprocess, a client for the server, and a transport.
164
131
        """
165
132
        # Serve from the current directory
166
 
        args = ['serve', '--inet']
167
 
        args.extend(extra_options)
168
 
        process = self.start_bzr_subprocess(args)
 
133
        process = self.start_bzr_subprocess(['serve', '--inet'])
169
134
 
170
135
        # Connect to the server
171
136
        # We use this url because while this is no valid URL to connect to this
195
160
        url = 'bzr://localhost:%d/' % port
196
161
        self.permit_url(url)
197
162
        return process, url
198
 
 
 
163
    
199
164
    def test_bzr_serve_quiet(self):
200
165
        self.make_branch('.')
201
166
        args = ['--port', 'localhost:0', '--quiet']
215
180
 
216
181
        process, transport = self.start_server_inet(['--allow-writes'])
217
182
 
218
 
        # We get a working branch, and can create a directory
 
183
        # We get a working branch
219
184
        branch = BzrDir.open_from_transport(transport).open_branch()
220
185
        self.make_read_requests(branch)
221
 
        transport.mkdir('adir')
222
186
        self.assertInetServerShutsdownCleanly(process)
223
187
 
224
188
    def test_bzr_serve_port_readonly(self):
225
189
        """bzr server should provide a read only filesystem by default."""
226
190
        process, url = self.start_server_port()
227
 
        t = transport.get_transport_from_url(url)
228
 
        self.assertRaises(errors.TransportNotPossible, t.mkdir, 'adir')
 
191
        transport = get_transport(url)
 
192
        self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
229
193
        self.assertServerFinishesCleanly(process)
230
194
 
231
195
    def test_bzr_serve_port_readwrite(self):
251
215
        self.make_read_requests(branch)
252
216
        self.assertServerFinishesCleanly(process)
253
217
 
254
 
    def test_bzr_serve_dhpss(self):
255
 
        # This is a smoke test that the server doesn't crash when run with
256
 
        # -Dhpss, and does drop some hpss logging to the file.
257
 
        self.make_branch('.')
258
 
        log_fname = os.getcwd() + '/server.log'
259
 
        self.overrideEnv('BZR_LOG', log_fname)
260
 
        process, transport = self.start_server_inet(['-Dhpss'])
261
 
        branch = BzrDir.open_from_transport(transport).open_branch()
262
 
        self.make_read_requests(branch)
263
 
        self.assertInetServerShutsdownCleanly(process)
264
 
        f = open(log_fname, 'rb')
265
 
        content = f.read()
266
 
        f.close()
267
 
        self.assertContainsRe(content, r'hpss request: \[[0-9-]+\]')
268
 
 
269
218
 
270
219
class TestCmdServeChrooting(TestBzrServeBase):
271
220
 
307
256
 
308
257
class TestUserdirExpansion(TestCaseWithMemoryTransport):
309
258
 
310
 
    @staticmethod
311
 
    def fake_expanduser(path):
 
259
    def fake_expanduser(self, path):
312
260
        """A simple, environment-independent, function for the duration of this
313
261
        test.
314
262
 
320
268
        return path
321
269
 
322
270
    def make_test_server(self, base_path='/'):
323
 
        """Make and start a BzrServerFactory, backed by a memory transport, and
 
271
        """Make and setUp a BzrServerFactory, backed by a memory transport, and
324
272
        creat '/home/user' in that transport.
325
273
        """
326
274
        bzr_server = BzrServerFactory(
366
314
        self.assertEqual(base_url, self.bzr_serve_transport.base)
367
315
        self.assertEqual(base_dir,
368
316
            server_maker.get_base_path(self.bzr_serve_transport))
 
317