/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/plugins/launchpad/test_lp_directory.py

merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/test_lp_directory.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 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
22
22
from bzrlib import (
23
23
    errors,
24
24
    tests,
 
25
    transport,
25
26
    )
26
27
from bzrlib.branch import Branch
27
28
from bzrlib.directory_service import directories
29
30
    TestCaseInTempDir,
30
31
    TestCaseWithMemoryTransport
31
32
)
32
 
from bzrlib.transport import get_transport
33
33
from bzrlib.plugins.launchpad import (
34
34
    _register_directory,
35
35
    lp_registration,
36
36
    )
37
37
from bzrlib.plugins.launchpad.lp_directory import (
38
38
    LaunchpadDirectory)
39
 
from bzrlib.plugins.launchpad.account import get_lp_login
40
 
from bzrlib.tests import (
41
 
    http_server,
42
 
    http_utils,
43
 
    )
 
39
from bzrlib.plugins.launchpad.account import get_lp_login, set_lp_login
 
40
from bzrlib.tests import http_server
44
41
 
45
42
 
46
43
def load_tests(standard_tests, module, loader):
94
91
        self.assertEquals('https://xmlrpc.launchpad.net/bazaar/',
95
92
                          factory._service_url)
96
93
 
 
94
    def test_qastaging(self):
 
95
        """A launchpad url should map to a http url"""
 
96
        factory = FakeResolveFactory(
 
97
            self, 'apt', dict(urls=[
 
98
                    'http://bazaar.qastaging.launchpad.net/~apt/apt/devel']))
 
99
        url = 'lp://qastaging/apt'
 
100
        directory = LaunchpadDirectory()
 
101
        self.assertEquals('http://bazaar.qastaging.launchpad.net/~apt/apt/devel',
 
102
                          directory._resolve(url, factory))
 
103
        # Make sure that resolve went to the qastaging server.
 
104
        self.assertEquals('https://xmlrpc.qastaging.launchpad.net/bazaar/',
 
105
                          factory._service_url)
 
106
 
97
107
    def test_staging(self):
98
108
        """A launchpad url should map to a http url"""
99
109
        factory = FakeResolveFactory(
199
209
        self.assertRaises(errors.InvalidURL,
200
210
            directory._resolve, 'lp://ratotehunoahu')
201
211
 
 
212
    def test_resolve_tilde_to_user(self):
 
213
        factory = FakeResolveFactory(
 
214
            self, '~username/apt/test', dict(urls=[
 
215
                    'bzr+ssh://bazaar.launchpad.net/~username/apt/test']))
 
216
        directory = LaunchpadDirectory()
 
217
        self.assertEquals(
 
218
            'bzr+ssh://bazaar.launchpad.net/~username/apt/test',
 
219
            directory._resolve('lp:~/apt/test', factory, _lp_login='username'))
 
220
        # Should also happen when the login is just set by config
 
221
        set_lp_login('username')
 
222
        self.assertEquals(
 
223
            'bzr+ssh://bazaar.launchpad.net/~username/apt/test',
 
224
            directory._resolve('lp:~/apt/test', factory))
 
225
 
 
226
    def test_tilde_fails_no_login(self):
 
227
        factory = FakeResolveFactory(
 
228
            self, '~username/apt/test', dict(urls=[
 
229
                    'bzr+ssh://bazaar.launchpad.net/~username/apt/test']))
 
230
        self.assertIs(None, get_lp_login())
 
231
        directory = LaunchpadDirectory()
 
232
        self.assertRaises(errors.InvalidURL,
 
233
                          directory._resolve, 'lp:~/apt/test', factory)
 
234
 
202
235
 
203
236
class DirectoryOpenBranchTests(TestCaseWithMemoryTransport):
204
237
 
214
247
                return '!unexpected look_up value!'
215
248
 
216
249
        directories.remove('lp:')
 
250
        directories.remove('ubuntu:')
 
251
        directories.remove('debianlp:')
217
252
        directories.register('lp:', FooService, 'Map lp URLs to local urls')
218
253
        self.addCleanup(_register_directory)
219
254
        self.addCleanup(directories.remove, 'lp:')
220
 
        transport = get_transport('lp:///apt')
221
 
        branch = Branch.open_from_transport(transport)
 
255
        t = transport.get_transport('lp:///apt')
 
256
        branch = Branch.open_from_transport(t)
222
257
        self.assertEqual(target_branch.base, branch.base)
223
258
 
224
259
 
236
271
    def handle_one_request(self):
237
272
        tcs = self.server.test_case_server
238
273
        requestline = self.rfile.readline()
239
 
        headers = self.MessageClass(self.rfile, 0)
 
274
        self.MessageClass(self.rfile, 0)
240
275
        if requestline.startswith('POST'):
241
276
            # The body should be a single line (or we don't know where it ends
242
277
            # and we don't want to issue a blocking read)
243
 
            body = self.rfile.readline()
 
278
            self.rfile.readline()
244
279
 
245
280
        self.wfile.write(tcs.canned_response)
246
281
 
276
311
        self.server = self.server_class()
277
312
        self.server.start_server()
278
313
        # Ensure we don't clobber env
279
 
        self._captureVar('BZR_LP_XMLRPC_URL', None)
 
314
        self.overrideEnv('BZR_LP_XMLRPC_URL', None)
280
315
 
281
316
    def tearDown(self):
282
317
        self.server.stop_server()
333
368
    # FIXME: we need to test with a real proxy, I can't find a way so simulate
334
369
    # CONNECT without leaving one server hanging the test :-/ Since that maybe
335
370
    # related to the leaking tests problems, I'll punt for now -- vila 20091030
 
371
 
 
372
 
 
373
class TestDebuntuExpansions(TestCaseInTempDir):
 
374
    """Test expansions for ubuntu: and debianlp: schemes."""
 
375
 
 
376
    def setUp(self):
 
377
        super(TestDebuntuExpansions, self).setUp()
 
378
        self.directory = LaunchpadDirectory()
 
379
 
 
380
    def _make_factory(self, package='foo', distro='ubuntu', series=None):
 
381
        if series is None:
 
382
            path = '%s/%s' % (distro, package)
 
383
            url_suffix = '~branch/%s/%s' % (distro, package)
 
384
        else:
 
385
            path = '%s/%s/%s' % (distro, series, package)
 
386
            url_suffix = '~branch/%s/%s/%s' % (distro, series, package)
 
387
        return FakeResolveFactory(
 
388
            self, path, dict(urls=[
 
389
                'http://bazaar.launchpad.net/' + url_suffix]))
 
390
 
 
391
    def assertURL(self, expected_url, shortcut, package='foo', distro='ubuntu',
 
392
                  series=None):
 
393
        factory = self._make_factory(package=package, distro=distro,
 
394
                                     series=series)
 
395
        self.assertEqual('http://bazaar.launchpad.net/~branch/' + expected_url,
 
396
                         self.directory._resolve(shortcut, factory))
 
397
 
 
398
    # Bogus distro.
 
399
 
 
400
    def test_bogus_distro(self):
 
401
        self.assertRaises(errors.InvalidURL,
 
402
                          self.directory._resolve, 'gentoo:foo')
 
403
 
 
404
    def test_trick_bogus_distro_u(self):
 
405
        self.assertRaises(errors.InvalidURL,
 
406
                          self.directory._resolve, 'utube:foo')
 
407
 
 
408
    def test_trick_bogus_distro_d(self):
 
409
        self.assertRaises(errors.InvalidURL,
 
410
                          self.directory._resolve, 'debuntu:foo')
 
411
 
 
412
    def test_missing_ubuntu_distroseries_without_project(self):
 
413
        # Launchpad does not hold source packages for Intrepid.  Missing or
 
414
        # bogus distroseries with no project name is treated like a project.
 
415
        self.assertURL('ubuntu/intrepid', 'ubuntu:intrepid', package='intrepid')
 
416
 
 
417
    def test_missing_ubuntu_distroseries_with_project(self):
 
418
        # Launchpad does not hold source packages for Intrepid.  Missing or
 
419
        # bogus distroseries with a project name is treated like an unknown
 
420
        # series (i.e. we keep it verbatim).
 
421
        self.assertURL('ubuntu/intrepid/foo',
 
422
                       'ubuntu:intrepid/foo', series='intrepid')
 
423
 
 
424
    def test_missing_debian_distroseries(self):
 
425
        # Launchpad does not hold source packages for unstable.  Missing or
 
426
        # bogus distroseries is treated like a project.
 
427
        self.assertURL('debian/sid',
 
428
                       'debianlp:sid', package='sid', distro='debian')
 
429
 
 
430
    # Ubuntu Default distro series.
 
431
 
 
432
    def test_ubuntu_default_distroseries_expansion(self):
 
433
        self.assertURL('ubuntu/foo', 'ubuntu:foo')
 
434
 
 
435
    def test_ubuntu_natty_distroseries_expansion(self):
 
436
        self.assertURL('ubuntu/natty/foo', 'ubuntu:natty/foo', series='natty')
 
437
 
 
438
    def test_ubuntu_n_distroseries_expansion(self):
 
439
        self.assertURL('ubuntu/natty/foo', 'ubuntu:n/foo', series='natty')
 
440
 
 
441
    def test_ubuntu_maverick_distroseries_expansion(self):
 
442
        self.assertURL('ubuntu/maverick/foo', 'ubuntu:maverick/foo',
 
443
                       series='maverick')
 
444
 
 
445
    def test_ubuntu_m_distroseries_expansion(self):
 
446
        self.assertURL('ubuntu/maverick/foo', 'ubuntu:m/foo', series='maverick')
 
447
 
 
448
    def test_ubuntu_lucid_distroseries_expansion(self):
 
449
        self.assertURL('ubuntu/lucid/foo', 'ubuntu:lucid/foo', series='lucid')
 
450
 
 
451
    def test_ubuntu_l_distroseries_expansion(self):
 
452
        self.assertURL('ubuntu/lucid/foo', 'ubuntu:l/foo', series='lucid')
 
453
 
 
454
    def test_ubuntu_karmic_distroseries_expansion(self):
 
455
        self.assertURL('ubuntu/karmic/foo', 'ubuntu:karmic/foo',
 
456
                       series='karmic')
 
457
 
 
458
    def test_ubuntu_k_distroseries_expansion(self):
 
459
        self.assertURL('ubuntu/karmic/foo', 'ubuntu:k/foo', series='karmic')
 
460
 
 
461
    def test_ubuntu_jaunty_distroseries_expansion(self):
 
462
        self.assertURL('ubuntu/jaunty/foo', 'ubuntu:jaunty/foo',
 
463
                       series='jaunty')
 
464
 
 
465
    def test_ubuntu_j_distroseries_expansion(self):
 
466
        self.assertURL('ubuntu/jaunty/foo', 'ubuntu:j/foo', series='jaunty')
 
467
 
 
468
    def test_ubuntu_hardy_distroseries_expansion(self):
 
469
        self.assertURL('ubuntu/hardy/foo', 'ubuntu:hardy/foo', series='hardy')
 
470
 
 
471
    def test_ubuntu_h_distroseries_expansion(self):
 
472
        self.assertURL('ubuntu/hardy/foo', 'ubuntu:h/foo', series='hardy')
 
473
 
 
474
    def test_ubuntu_dapper_distroseries_expansion(self):
 
475
        self.assertURL('ubuntu/dapper/foo', 'ubuntu:dapper/foo',
 
476
                       series='dapper')
 
477
 
 
478
    def test_ubuntu_d_distroseries_expansion(self):
 
479
        self.assertURL('ubuntu/dapper/foo', 'ubuntu:d/foo', series='dapper')
 
480
 
 
481
    # Debian default distro series.
 
482
 
 
483
    def test_debian_default_distroseries_expansion(self):
 
484
        self.assertURL('debian/foo', 'debianlp:foo', distro='debian')
 
485
 
 
486
    def test_debian_squeeze_distroseries_expansion(self):
 
487
        self.assertURL('debian/squeeze/foo', 'debianlp:squeeze/foo',
 
488
                       distro='debian', series='squeeze')
 
489
 
 
490
    def test_debian_lenny_distroseries_expansion(self):
 
491
        self.assertURL('debian/lenny/foo', 'debianlp:lenny/foo',
 
492
                       distro='debian', series='lenny')