← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_utils.py

  • Committer: Jelmer Vernooij
  • Date: 2010-08-23 20:37:18 UTC
  • mto: This revision was merged to the branch mainline in revision 5389.
  • Revision ID: jelmer@samba.org-20100823203718-1fj7rrjsiaxedkp7
Provide bzrlib.bzrdir.format_registry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_utils.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
58
58
        """Hand the request off to a smart server instance."""
59
59
        backing = get_transport(self.server.test_case_server._home_dir)
60
60
        chroot_server = chroot.ChrootServer(backing)
61
 
        chroot_server.setUp()
 
61
        chroot_server.start_server()
62
62
        try:
63
63
            t = get_transport(chroot_server.get_url())
64
64
            self.do_POST_inner(t)
65
65
        finally:
66
 
            chroot_server.tearDown()
 
66
            chroot_server.stop_server()
67
67
 
68
68
    def do_POST_inner(self, chrooted_transport):
69
69
        self.send_response(200)
106
106
    one. This will currently fail if the primary transport is not
107
107
    backed by regular disk files.
108
108
    """
 
109
 
 
110
    # This can be overriden or parametrized by daughter clasess if needed, but
 
111
    # it must exist so that the create_transport_readonly_server() method can
 
112
    # propagate it.
 
113
    _protocol_version = None
 
114
 
109
115
    def setUp(self):
110
116
        super(TestCaseWithWebserver, self).setUp()
111
117
        self.transport_readonly_server = http_server.HttpServer
112
118
 
 
119
    def create_transport_readonly_server(self):
 
120
        return self.transport_readonly_server(
 
121
            protocol_version=self._protocol_version)
 
122
 
113
123
 
114
124
class TestCaseWithTwoWebservers(TestCaseWithWebserver):
115
125
    """A support class providing readonly urls on two servers that are http://.
127
137
 
128
138
        This is mostly a hook for daughter classes.
129
139
        """
130
 
        return self.transport_secondary_server()
 
140
        return self.transport_secondary_server(
 
141
            protocol_version=self._protocol_version)
131
142
 
132
143
    def get_secondary_server(self):
133
144
        """Get the server instance for the secondary transport."""
134
145
        if self.__secondary_server is None:
135
146
            self.__secondary_server = self.create_transport_secondary_server()
136
 
            self.__secondary_server.setUp()
137
 
            self.addCleanup(self.__secondary_server.tearDown)
 
147
            self.start_server(self.__secondary_server)
138
148
        return self.__secondary_server
139
149
 
140
150
 
219
229
   def create_transport_secondary_server(self):
220
230
       """Create the secondary server redirecting to the primary server"""
221
231
       new = self.get_readonly_server()
222
 
       redirecting = HTTPServerRedirecting()
 
232
       redirecting = HTTPServerRedirecting(
 
233
           protocol_version=self._protocol_version)
223
234
       redirecting.redirect_to(new.host, new.port)
224
235
       return redirecting
225
236
 
297
308
 
298
309
    def authorized(self):
299
310
        tcs = self.server.test_case_server
300
 
        if tcs.auth_scheme != 'digest':
301
 
            return False
302
311
 
303
312
        auth_header = self.headers.get(tcs.auth_header_recv, None)
304
313
        if auth_header is None:
319
328
        self.send_header(tcs.auth_header_sent,header)
320
329
 
321
330
 
 
331
class DigestAndBasicAuthRequestHandler(DigestAuthRequestHandler):
 
332
    """Implements a digest and basic authentication of a request.
 
333
 
 
334
    I.e. the server proposes both schemes and the client should choose the best
 
335
    one it can handle, which, in that case, should be digest, the only scheme
 
336
    accepted here.
 
337
    """
 
338
 
 
339
    def send_header_auth_reqed(self):
 
340
        tcs = self.server.test_case_server
 
341
        self.send_header(tcs.auth_header_sent,
 
342
                         'Basic realm="%s"' % tcs.auth_realm)
 
343
        header = 'Digest realm="%s", ' % tcs.auth_realm
 
344
        header += 'nonce="%s", algorithm="%s", qop="auth"' % (tcs.auth_nonce,
 
345
                                                              'MD5')
 
346
        self.send_header(tcs.auth_header_sent,header)
 
347
 
 
348
 
322
349
class AuthServer(http_server.HttpServer):
323
350
    """Extends HttpServer with a dictionary of passwords.
324
351
 
410
437
 
411
438
        return response_digest == auth['response']
412
439
 
 
440
 
413
441
class HTTPAuthServer(AuthServer):
414
442
    """An HTTP server requiring authentication"""
415
443
 
447
475
        self.init_http_auth()
448
476
 
449
477
 
 
478
class HTTPBasicAndDigestAuthServer(DigestAuthServer, HTTPAuthServer):
 
479
    """An HTTP server requiring basic or digest authentication"""
 
480
 
 
481
    def __init__(self, protocol_version=None):
 
482
        DigestAuthServer.__init__(self, DigestAndBasicAuthRequestHandler,
 
483
                                  'basicdigest',
 
484
                                  protocol_version=protocol_version)
 
485
        self.init_http_auth()
 
486
        # We really accept Digest only
 
487
        self.auth_scheme = 'digest'
 
488
 
 
489
 
450
490
class ProxyBasicAuthServer(ProxyAuthServer):
451
491
    """A proxy server requiring basic authentication"""
452
492
 
465
505
        self.init_proxy_auth()
466
506
 
467
507
 
 
508
class ProxyBasicAndDigestAuthServer(DigestAuthServer, ProxyAuthServer):
 
509
    """An proxy server requiring basic or digest authentication"""
 
510
 
 
511
    def __init__(self, protocol_version=None):
 
512
        DigestAuthServer.__init__(self, DigestAndBasicAuthRequestHandler,
 
513
                                  'basicdigest',
 
514
                                  protocol_version=protocol_version)
 
515
        self.init_proxy_auth()
 
516
        # We really accept Digest only
 
517
        self.auth_scheme = 'digest'
 
518
 
 
519