← 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: Vincent Ladeuil
  • Date: 2007-10-09 20:32:29 UTC
  • mto: (2903.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 2904.
  • Revision ID: v.ladeuil+lp@free.fr-20071009203229-5k200m1g7mf4jf9l
Fix 149019 by using a proper line number when reporting errors.

* bzrlib/util/configobj/configobj.py:
(ConfigObj._handle_error): Trivial fix. Since cur_index is
0-based, line number was off by one.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_serve.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
"""Tests of the bzr serve command."""
21
21
import signal
22
22
import subprocess
23
23
import sys
24
 
import thread
25
24
import threading
26
25
 
27
26
from bzrlib import (
28
27
    errors,
29
28
    osutils,
30
29
    revision as _mod_revision,
31
 
    transport,
32
30
    )
33
31
from bzrlib.branch import Branch
34
32
from bzrlib.bzrdir import BzrDir
35
33
from bzrlib.errors import ParamikoNotPresent
36
 
from bzrlib.smart import client, medium
37
 
from bzrlib.smart.server import SmartTCPServer
 
34
from bzrlib.smart import medium
38
35
from bzrlib.tests import TestCaseWithTransport, TestSkipped
39
 
from bzrlib.trace import mutter
40
36
from bzrlib.transport import get_transport, remote
41
37
 
42
38
 
52
48
        result = self.finish_bzr_subprocess(process)
53
49
        self.assertEqual('', result[0])
54
50
        self.assertEqual('', result[1])
55
 
 
 
51
    
56
52
    def assertServerFinishesCleanly(self, process):
57
53
        """Shutdown the bzr serve instance process looking for errors."""
58
54
        # Shutdown the server
61
57
        self.assertEqual('', result[0])
62
58
        self.assertEqual('bzr: interrupted\n', result[1])
63
59
 
64
 
    def make_read_requests(self, branch):
65
 
        """Do some read only requests."""
66
 
        branch.lock_read()
67
 
        try:
68
 
            branch.repository.all_revision_ids()
69
 
            self.assertEqual(_mod_revision.NULL_REVISION,
70
 
                             _mod_revision.ensure_null(branch.last_revision()))
71
 
        finally:
72
 
            branch.unlock()
73
 
 
74
60
    def start_server_inet(self, extra_options=()):
75
61
        """Start a bzr server subprocess using the --inet option.
76
62
 
84
70
        # Connect to the server
85
71
        # We use this url because while this is no valid URL to connect to this
86
72
        # server instance, the transport needs a URL.
87
 
        url = 'bzr://localhost/'
88
73
        client_medium = medium.SmartSimplePipesClientMedium(
89
 
            process.stdout, process.stdin, url)
90
 
        transport = remote.RemoteTransport(url, medium=client_medium)
 
74
            process.stdout, process.stdin)
 
75
        transport = remote.RemoteTransport(
 
76
            'bzr://localhost/', medium=client_medium)
91
77
        return process, transport
92
78
 
93
79
    def start_server_port(self, extra_options=()):
101
87
        args = ['serve', '--port', 'localhost:0']
102
88
        args.extend(extra_options)
103
89
        process = self.start_bzr_subprocess(args, skip_if_plan_to_signal=True)
104
 
        port_line = process.stderr.readline()
 
90
        port_line = process.stdout.readline()
105
91
        prefix = 'listening on port: '
106
92
        self.assertStartsWith(port_line, prefix)
107
93
        port = int(port_line[len(prefix):])
121
107
 
122
108
        # We get a working branch
123
109
        branch = BzrDir.open_from_transport(transport).open_branch()
124
 
        self.make_read_requests(branch)
 
110
        branch.repository.get_revision_graph()
 
111
        self.assertEqual(_mod_revision.NULL_REVISION,
 
112
                         _mod_revision.ensure_null(branch.last_revision()))
125
113
        self.assertInetServerShutsdownCleanly(process)
126
114
 
127
115
    def test_bzr_serve_port_readonly(self):
139
127
 
140
128
        # Connect to the server
141
129
        branch = Branch.open(url)
142
 
        self.make_read_requests(branch)
143
 
        self.assertServerFinishesCleanly(process)
144
 
 
145
 
    def test_bzr_serve_supports_protocol(self):
146
 
        # Make a branch
147
 
        self.make_branch('.')
148
 
 
149
 
        process, url = self.start_server_port(['--allow-writes',
150
 
                                               '--protocol=bzr'])
151
 
 
152
 
        # Connect to the server
153
 
        branch = Branch.open(url)
154
 
        self.make_read_requests(branch)
 
130
 
 
131
        # We get a working branch
 
132
        branch.repository.get_revision_graph()
 
133
        self.assertEqual(_mod_revision.NULL_REVISION,
 
134
                         _mod_revision.ensure_null(branch.last_revision()))
 
135
 
155
136
        self.assertServerFinishesCleanly(process)
156
137
 
157
138
    def test_bzr_connect_to_bzr_ssh(self):
164
145
        except ParamikoNotPresent:
165
146
            raise TestSkipped('Paramiko not installed')
166
147
        from bzrlib.tests.stub_sftp import StubServer
167
 
 
 
148
        
168
149
        # Make a branch
169
150
        self.make_branch('a_branch')
170
151
 
183
164
                proc = subprocess.Popen(
184
165
                    command, shell=True, stdin=subprocess.PIPE,
185
166
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE)
186
 
 
 
167
                
187
168
                # XXX: horribly inefficient, not to mention ugly.
188
169
                # Start a thread for each of stdin/out/err, and relay bytes from
189
170
                # the subprocess to channel and vice versa.
216
197
        # Access the branch via a bzr+ssh URL.  The BZR_REMOTE_PATH environment
217
198
        # variable is used to tell bzr what command to run on the remote end.
218
199
        path_to_branch = osutils.abspath('a_branch')
219
 
 
 
200
        
220
201
        orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
221
202
        bzr_remote_path = self.get_bzr_path()
222
203
        if sys.platform == 'win32':
227
208
                path_to_branch = os.path.splitdrive(path_to_branch)[1]
228
209
            branch = Branch.open(
229
210
                'bzr+ssh://fred:secret@localhost:%d%s' % (port, path_to_branch))
230
 
            self.make_read_requests(branch)
 
211
            
 
212
            branch.repository.get_revision_graph()
 
213
            self.assertEqual(_mod_revision.NULL_REVISION,
 
214
                             _mod_revision.ensure_null(branch.last_revision()))
231
215
            # Check we can perform write operations
232
216
            branch.bzrdir.root_transport.mkdir('foo')
233
217
        finally:
242
226
            ['%s serve --inet --directory=/ --allow-writes'
243
227
             % bzr_remote_path],
244
228
            self.command_executed)
245
 
 
246
 
 
247
 
class TestCmdServeChrooting(TestCaseWithTransport):
248
 
 
249
 
    def test_serve_tcp(self):
250
 
        """'bzr serve' wraps the given --directory in a ChrootServer.
251
 
 
252
 
        So requests that search up through the parent directories (like
253
 
        find_repositoryV3) will give "not found" responses, rather than
254
 
        InvalidURLJoin or jail break errors.
255
 
        """
256
 
        t = self.get_transport()
257
 
        t.mkdir('server-root')
258
 
        self.run_bzr_serve_then_func(
259
 
            ['--port', '0', '--directory', t.local_abspath('server-root'),
260
 
             '--allow-writes'],
261
 
            self.when_server_started)
262
 
        # The when_server_started method issued a find_repositoryV3 that should
263
 
        # fail with 'norepository' because there are no repositories inside the
264
 
        # --directory.
265
 
        self.assertEqual(('norepository',), self.client_resp)
266
 
        
267
 
    def run_bzr_serve_then_func(self, serve_args, func, *func_args,
268
 
            **func_kwargs):
269
 
        """Run 'bzr serve', and run the given func in a thread once the server
270
 
        has started.
271
 
        
272
 
        When 'func' terminates, the server will be terminated too.
273
 
        """
274
 
        # install hook
275
 
        def on_server_start(backing_urls, tcp_server):
276
 
            t = threading.Thread(
277
 
                target=on_server_start_thread, args=(tcp_server,))
278
 
            t.start()
279
 
        def on_server_start_thread(tcp_server):
280
 
            try:
281
 
                # Run func
282
 
                self.tcp_server = tcp_server
283
 
                try:
284
 
                    func(*func_args, **func_kwargs)
285
 
                except Exception, e:
286
 
                    # Log errors to make some test failures a little less
287
 
                    # mysterious.
288
 
                    mutter('func broke: %r', e)
289
 
            finally:
290
 
                # Then stop the server
291
 
                mutter('interrupting...')
292
 
                thread.interrupt_main()
293
 
        SmartTCPServer.hooks.install_named_hook(
294
 
            'server_started_ex', on_server_start,
295
 
            'run_bzr_serve_then_func hook')
296
 
        # start a TCP server
297
 
        try:
298
 
            self.run_bzr(['serve'] + list(serve_args))
299
 
        except KeyboardInterrupt:
300
 
            pass
301
 
 
302
 
    def when_server_started(self):
303
 
        # Connect to the TCP server and issue some requests and see what comes
304
 
        # back.
305
 
        client_medium = medium.SmartTCPClientMedium(
306
 
            '127.0.0.1', self.tcp_server.port,
307
 
            'bzr://localhost:%d/' % (self.tcp_server.port,))
308
 
        smart_client = client._SmartClient(client_medium)
309
 
        resp = smart_client.call('mkdir', 'foo', '')
310
 
        resp = smart_client.call('BzrDirFormat.initialize', 'foo/')
311
 
        try:
312
 
            resp = smart_client.call('BzrDir.find_repositoryV3', 'foo/')
313
 
        except errors.ErrorFromSmartServer, e:
314
 
            resp = e.error_tuple
315
 
        self.client_resp = resp
316
 
        client_medium.disconnect()
317
 
 
318
 
 
319
 
 
 
229