← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/plugins/launchpad/test_lp_directory.py
1
 
# Copyright (C) 2007-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2007-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
19
19
import os
20
20
import xmlrpclib
21
21
 
22
 
import bzrlib
23
22
from bzrlib import (
24
 
    debug,
25
23
    errors,
26
24
    tests,
27
25
    transport,
29
27
from bzrlib.branch import Branch
30
28
from bzrlib.directory_service import directories
31
29
from bzrlib.tests import (
32
 
    features,
33
 
    ssl_certs,
34
30
    TestCaseInTempDir,
35
31
    TestCaseWithMemoryTransport
36
32
)
41
37
from bzrlib.plugins.launchpad.lp_directory import (
42
38
    LaunchpadDirectory)
43
39
from bzrlib.plugins.launchpad.account import get_lp_login, set_lp_login
44
 
from bzrlib.tests import http_server
 
40
from bzrlib.tests import (
 
41
    http_server,
 
42
    http_utils,
 
43
    )
45
44
 
46
45
 
47
46
def load_tests(standard_tests, module, loader):
53
52
    transport_scenarios = [
54
53
        ('http', dict(server_class=PreCannedHTTPServer,)),
55
54
        ]
56
 
    if features.HTTPSServerFeature.available():
 
55
    if tests.HTTPSServerFeature.available():
57
56
        transport_scenarios.append(
58
57
            ('https', dict(server_class=PreCannedHTTPSServer,)),
59
58
            )
66
65
 
67
66
 
68
67
class FakeResolveFactory(object):
69
 
 
70
68
    def __init__(self, test, expected_path, result):
71
69
        self._test = test
72
70
        self._expected_path = expected_path
73
71
        self._result = result
74
 
        self._submitted = False
75
72
 
76
73
    def __call__(self, path):
77
74
        self._test.assertEqual(self._expected_path, path)
79
76
 
80
77
    def submit(self, service):
81
78
        self._service_url = service.service_url
82
 
        self._submitted = True
83
79
        return self._result
84
80
 
85
81
 
86
 
class LocalDirectoryURLTests(TestCaseInTempDir):
87
 
    """Tests for branch urls that we try to pass through local resolution."""
88
 
 
89
 
    def assertResolve(self, expected, url, submitted=False):
90
 
        path = url[url.index(':')+1:].lstrip('/')
91
 
        factory = FakeResolveFactory(self, path,
92
 
                    dict(urls=['bzr+ssh://fake-resolved']))
93
 
        directory = LaunchpadDirectory()
94
 
        self.assertEqual(expected,
95
 
            directory._resolve(url, factory, _lp_login='user'))
96
 
        # We are testing local resolution, and the fallback when necessary.
97
 
        self.assertEqual(submitted, factory._submitted)
98
 
 
99
 
    def test_short_form(self):
100
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt',
101
 
                           'lp:apt')
102
 
 
103
 
    def test_two_part_form(self):
104
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt/2.2',
105
 
                           'lp:apt/2.2')
106
 
 
107
 
    def test_two_part_plus_subdir(self):
108
 
        # We allow you to pass more than just what resolves. That way you can
109
 
        # do things like "bzr log lp:apt/2.2/BUGS"
110
 
        # Though the virtual FS implementation currently aborts when given a
111
 
        # URL like this, rather than letting you recurse upwards to find the
112
 
        # real branch at lp:apt/2.2
113
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt/2.2/BUGS',
114
 
                           'lp:apt/2.2/BUGS')
115
 
 
116
 
    def test_user_expansion(self):
117
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/~user/apt/foo',
118
 
                           'lp:~/apt/foo')
119
 
 
120
 
    def test_ubuntu(self):
121
 
        # Confirmed against xmlrpc. If you don't have a ~user, xmlrpc doesn't
122
 
        # care that you are asking for 'ubuntu'
123
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/ubuntu',
124
 
                           'lp:ubuntu')
125
 
 
126
 
    def test_ubuntu_invalid(self):
127
 
        """Invalid ubuntu urls don't crash.
128
 
 
129
 
        :seealso: http://pad.lv/843900
130
 
        """
131
 
        # This ought to be natty-updates.
132
 
        self.assertRaises(errors.InvalidURL,
133
 
            self.assertResolve,
134
 
            '',
135
 
            'ubuntu:natty/updates/smartpm')
136
 
 
137
 
    def test_ubuntu_apt(self):
138
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/ubuntu/apt',
139
 
                           'lp:ubuntu/apt')
140
 
 
141
 
    def test_ubuntu_natty_apt(self):
142
 
        self.assertResolve(
143
 
            'bzr+ssh://bazaar.launchpad.net/+branch/ubuntu/natty/apt',
144
 
            'lp:ubuntu/natty/apt')
145
 
 
146
 
    def test_ubuntu_natty_apt_filename(self):
147
 
        self.assertResolve(
148
 
            'bzr+ssh://bazaar.launchpad.net/+branch/ubuntu/natty/apt/filename',
149
 
            'lp:ubuntu/natty/apt/filename')
150
 
 
151
 
    def test_user_two_part(self):
152
 
        # We fall back to the ResolveFactory. The real Launchpad one will raise
153
 
        # InvalidURL for this case.
154
 
        self.assertResolve('bzr+ssh://fake-resolved', 'lp:~jameinel/apt',
155
 
                           submitted=True)
156
 
 
157
 
    def test_user_three_part(self):
158
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/~jameinel/apt/foo',
159
 
                           'lp:~jameinel/apt/foo')
160
 
 
161
 
    def test_user_three_part_plus_filename(self):
162
 
        self.assertResolve(
163
 
            'bzr+ssh://bazaar.launchpad.net/~jameinel/apt/foo/fname',
164
 
            'lp:~jameinel/apt/foo/fname')
165
 
 
166
 
    def test_user_ubuntu_two_part(self):
167
 
        self.assertResolve('bzr+ssh://fake-resolved', 'lp:~jameinel/ubuntu',
168
 
                           submitted=True)
169
 
        self.assertResolve('bzr+ssh://fake-resolved', 'lp:~jameinel/debian',
170
 
                           submitted=True)
171
 
 
172
 
    def test_user_ubuntu_three_part(self):
173
 
        self.assertResolve('bzr+ssh://fake-resolved',
174
 
                           'lp:~jameinel/ubuntu/natty', submitted=True)
175
 
        self.assertResolve('bzr+ssh://fake-resolved',
176
 
                           'lp:~jameinel/debian/sid', submitted=True)
177
 
 
178
 
    def test_user_ubuntu_four_part(self):
179
 
        self.assertResolve('bzr+ssh://fake-resolved',
180
 
                           'lp:~jameinel/ubuntu/natty/project', submitted=True)
181
 
        self.assertResolve('bzr+ssh://fake-resolved',
182
 
                           'lp:~jameinel/debian/sid/project', submitted=True)
183
 
 
184
 
    def test_user_ubuntu_five_part(self):
185
 
        self.assertResolve(
186
 
            'bzr+ssh://bazaar.launchpad.net/~jameinel/ubuntu/natty/apt/branch',
187
 
            'lp:~jameinel/ubuntu/natty/apt/branch')
188
 
        self.assertResolve(
189
 
            'bzr+ssh://bazaar.launchpad.net/~jameinel/debian/sid/apt/branch',
190
 
            'lp:~jameinel/debian/sid/apt/branch')
191
 
 
192
 
    def test_user_ubuntu_five_part_plus_subdir(self):
193
 
        self.assertResolve(
194
 
            'bzr+ssh://bazaar.launchpad.net/~jameinel/ubuntu/natty/apt/branch/f',
195
 
            'lp:~jameinel/ubuntu/natty/apt/branch/f')
196
 
        self.assertResolve(
197
 
            'bzr+ssh://bazaar.launchpad.net/~jameinel/debian/sid/apt/branch/f',
198
 
            'lp:~jameinel/debian/sid/apt/branch/f')
199
 
 
200
 
    def test_handles_special_lp(self):
201
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt', 'lp:apt')
202
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt',
203
 
                           'lp:///apt')
204
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/apt',
205
 
                           'lp://production/apt')
206
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.dev/+branch/apt',
207
 
                           'lp://dev/apt')
208
 
        self.assertResolve('bzr+ssh://bazaar.staging.launchpad.net/+branch/apt',
209
 
                           'lp://staging/apt')
210
 
        self.assertResolve('bzr+ssh://bazaar.qastaging.launchpad.net/+branch/apt',
211
 
                           'lp://qastaging/apt')
212
 
        self.assertResolve('bzr+ssh://bazaar.demo.launchpad.net/+branch/apt',
213
 
                           'lp://demo/apt')
214
 
 
215
 
    def test_debug_launchpad_uses_resolver(self):
216
 
        self.assertResolve('bzr+ssh://bazaar.launchpad.net/+branch/bzr',
217
 
                           'lp:bzr', submitted=False)
218
 
        debug.debug_flags.add('launchpad')
219
 
        self.addCleanup(debug.debug_flags.discard, 'launchpad')
220
 
        self.assertResolve('bzr+ssh://fake-resolved', 'lp:bzr', submitted=True)
221
 
 
222
 
 
223
82
class DirectoryUrlTests(TestCaseInTempDir):
224
83
    """Tests for branch urls through Launchpad.net directory"""
225
84
 
229
88
            self, 'apt', dict(urls=[
230
89
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
231
90
        directory = LaunchpadDirectory()
232
 
        self.assertEqual('http://bazaar.launchpad.net/~apt/apt/devel',
 
91
        self.assertEquals('http://bazaar.launchpad.net/~apt/apt/devel',
233
92
                          directory._resolve('lp:apt', factory))
234
93
        # Make sure that resolve went to the production server.
235
 
        self.assertEqual('https://xmlrpc.launchpad.net/bazaar/',
236
 
                          factory._service_url)
237
 
 
238
 
    def test_qastaging(self):
239
 
        """A launchpad url should map to a http url"""
240
 
        factory = FakeResolveFactory(
241
 
            self, 'apt', dict(urls=[
242
 
                    'http://bazaar.qastaging.launchpad.net/~apt/apt/devel']))
243
 
        url = 'lp://qastaging/apt'
244
 
        directory = LaunchpadDirectory()
245
 
        self.assertEqual('http://bazaar.qastaging.launchpad.net/~apt/apt/devel',
246
 
                          directory._resolve(url, factory))
247
 
        # Make sure that resolve went to the qastaging server.
248
 
        self.assertEqual('https://xmlrpc.qastaging.launchpad.net/bazaar/',
 
94
        self.assertEquals('https://xmlrpc.launchpad.net/bazaar/',
249
95
                          factory._service_url)
250
96
 
251
97
    def test_staging(self):
255
101
                    'http://bazaar.staging.launchpad.net/~apt/apt/devel']))
256
102
        url = 'lp://staging/apt'
257
103
        directory = LaunchpadDirectory()
258
 
        self.assertEqual('http://bazaar.staging.launchpad.net/~apt/apt/devel',
 
104
        self.assertEquals('http://bazaar.staging.launchpad.net/~apt/apt/devel',
259
105
                          directory._resolve(url, factory))
260
106
        # Make sure that resolve went to the staging server.
261
 
        self.assertEqual('https://xmlrpc.staging.launchpad.net/bazaar/',
 
107
        self.assertEquals('https://xmlrpc.staging.launchpad.net/bazaar/',
262
108
                          factory._service_url)
263
109
 
264
110
    def test_url_from_directory(self):
267
113
            self, 'apt', dict(urls=[
268
114
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
269
115
        directory = LaunchpadDirectory()
270
 
        self.assertEqual('http://bazaar.launchpad.net/~apt/apt/devel',
 
116
        self.assertEquals('http://bazaar.launchpad.net/~apt/apt/devel',
271
117
                          directory._resolve('lp:///apt', factory))
272
118
 
273
119
    def test_directory_skip_bad_schemes(self):
277
123
                    'http://bazaar.launchpad.net/~apt/apt/devel',
278
124
                    'http://another/location']))
279
125
        directory = LaunchpadDirectory()
280
 
        self.assertEqual('http://bazaar.launchpad.net/~apt/apt/devel',
 
126
        self.assertEquals('http://bazaar.launchpad.net/~apt/apt/devel',
281
127
                          directory._resolve('lp:///apt', factory))
282
128
 
283
129
    def test_directory_no_matching_schemes(self):
309
155
                    'bzr+ssh://bazaar.launchpad.net/~apt/apt/devel',
310
156
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
311
157
        directory = LaunchpadDirectory()
312
 
        self.assertEqual('http://bazaar.launchpad.net/~apt/apt/devel',
 
158
        self.assertEquals('http://bazaar.launchpad.net/~apt/apt/devel',
313
159
                          directory._resolve('lp:///apt', factory))
314
160
 
315
161
    def test_skip_sftp_launchpad_net_when_anonymous(self):
321
167
                    'sftp://bazaar.launchpad.net/~apt/apt/devel',
322
168
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
323
169
        directory = LaunchpadDirectory()
324
 
        self.assertEqual('http://bazaar.launchpad.net/~apt/apt/devel',
 
170
        self.assertEquals('http://bazaar.launchpad.net/~apt/apt/devel',
325
171
                          directory._resolve('lp:///apt', factory))
326
172
 
327
 
    def test_with_login_avoid_resolve_factory(self):
 
173
    def test_rewrite_bzr_ssh_launchpad_net(self):
328
174
        # Test that bzr+ssh URLs get rewritten to include the user's
329
175
        # Launchpad ID (assuming we know the Launchpad ID).
330
176
        factory = FakeResolveFactory(
331
177
            self, 'apt', dict(urls=[
332
 
                    'bzr+ssh://my-super-custom/special/devel',
 
178
                    'bzr+ssh://bazaar.launchpad.net/~apt/apt/devel',
333
179
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
334
180
        directory = LaunchpadDirectory()
335
 
        self.assertEqual(
336
 
            'bzr+ssh://bazaar.launchpad.net/+branch/apt',
 
181
        self.assertEquals(
 
182
            'bzr+ssh://bazaar.launchpad.net/~apt/apt/devel',
337
183
            directory._resolve('lp:///apt', factory, _lp_login='username'))
338
184
 
339
185
    def test_no_rewrite_of_other_bzr_ssh(self):
344
190
                    'bzr+ssh://example.com/~apt/apt/devel',
345
191
                    'http://bazaar.launchpad.net/~apt/apt/devel']))
346
192
        directory = LaunchpadDirectory()
347
 
        self.assertEqual('bzr+ssh://example.com/~apt/apt/devel',
 
193
        self.assertEquals('bzr+ssh://example.com/~apt/apt/devel',
348
194
                          directory._resolve('lp:///apt', factory))
349
195
 
350
196
    # TODO: check we get an error if the url is unreasonable
356
202
    def test_resolve_tilde_to_user(self):
357
203
        factory = FakeResolveFactory(
358
204
            self, '~username/apt/test', dict(urls=[
359
 
                'bzr+ssh://bazaar.launchpad.net/~username/apt/test']))
 
205
                    'bzr+ssh://bazaar.launchpad.net/~username/apt/test']))
360
206
        directory = LaunchpadDirectory()
361
 
        self.assertEqual(
 
207
        self.assertEquals(
362
208
            'bzr+ssh://bazaar.launchpad.net/~username/apt/test',
363
209
            directory._resolve('lp:~/apt/test', factory, _lp_login='username'))
364
210
        # Should also happen when the login is just set by config
365
211
        set_lp_login('username')
366
 
        self.assertEqual(
 
212
        self.assertEquals(
367
213
            'bzr+ssh://bazaar.launchpad.net/~username/apt/test',
368
214
            directory._resolve('lp:~/apt/test', factory))
369
215
 
373
219
                    'bzr+ssh://bazaar.launchpad.net/~username/apt/test']))
374
220
        self.assertIs(None, get_lp_login())
375
221
        directory = LaunchpadDirectory()
376
 
        self.assertRaises(errors.InvalidURL,
377
 
                          directory._resolve, 'lp:~/apt/test', factory)
 
222
        e = self.assertRaises(errors.InvalidURL,
 
223
            directory._resolve, 'lp:~/apt/test', factory)
378
224
 
379
225
 
380
226
class DirectoryOpenBranchTests(TestCaseWithMemoryTransport):
391
237
                return '!unexpected look_up value!'
392
238
 
393
239
        directories.remove('lp:')
394
 
        directories.remove('ubuntu:')
395
 
        directories.remove('debianlp:')
396
240
        directories.register('lp:', FooService, 'Map lp URLs to local urls')
397
241
        self.addCleanup(_register_directory)
398
242
        self.addCleanup(directories.remove, 'lp:')
415
259
    def handle_one_request(self):
416
260
        tcs = self.server.test_case_server
417
261
        requestline = self.rfile.readline()
418
 
        self.MessageClass(self.rfile, 0)
 
262
        headers = self.MessageClass(self.rfile, 0)
419
263
        if requestline.startswith('POST'):
420
264
            # The body should be a single line (or we don't know where it ends
421
265
            # and we don't want to issue a blocking read)
422
 
            self.rfile.readline()
 
266
            body = self.rfile.readline()
423
267
 
424
268
        self.wfile.write(tcs.canned_response)
425
269
 
439
283
    pass
440
284
 
441
285
 
442
 
if features.HTTPSServerFeature.available():
 
286
if tests.HTTPSServerFeature.available():
443
287
    from bzrlib.tests import https_server
444
288
    class PreCannedHTTPSServer(PreCannedServerMixin, https_server.HTTPSServer):
445
289
        pass
451
295
    server_class = None
452
296
 
453
297
    def setUp(self):
454
 
        super(TestXMLRPCTransport, self).setUp()
 
298
        tests.TestCase.setUp(self)
455
299
        self.server = self.server_class()
456
300
        self.server.start_server()
457
 
        self.addCleanup(self.server.stop_server)
458
301
        # Ensure we don't clobber env
459
 
        self.overrideEnv('BZR_LP_XMLRPC_URL', None)
460
 
        # Ensure we use the right certificates for https.
461
 
        # FIXME: There should be a better way but the only alternative I can
462
 
        # think of involves carrying the ca_certs through the lp_registration
463
 
        # infrastructure to _urllib2_wrappers... -- vila 2012-01-20
464
 
        bzrlib.global_state.cmdline_overrides._from_cmdline(
465
 
            ['ssl.ca_certs=%s' % ssl_certs.build_path('ca.crt')])
 
302
        self._captureVar('BZR_LP_XMLRPC_URL', None)
 
303
 
 
304
    def tearDown(self):
 
305
        self.server.stop_server()
 
306
        tests.TestCase.tearDown(self)
466
307
 
467
308
    def set_canned_response(self, server, path):
468
309
        response_format = '''HTTP/1.1 200 OK\r
508
349
        result = self.do_request(self.server.get_url())
509
350
        urls = result.get('urls', None)
510
351
        self.assertIsNot(None, urls)
511
 
        self.assertEqual(
 
352
        self.assertEquals(
512
353
            ['bzr+ssh://bazaar.launchpad.net/~bzr-pqm/bzr/bzr.dev',
513
354
             'http://bazaar.launchpad.net/~bzr-pqm/bzr/bzr.dev'],
514
355
            urls)
515
356
    # FIXME: we need to test with a real proxy, I can't find a way so simulate
516
357
    # CONNECT without leaving one server hanging the test :-/ Since that maybe
517
358
    # related to the leaking tests problems, I'll punt for now -- vila 20091030
518
 
 
519
 
 
520
 
class TestDebuntuExpansions(TestCaseInTempDir):
521
 
    """Test expansions for ubuntu: and debianlp: schemes."""
522
 
 
523
 
    def setUp(self):
524
 
        super(TestDebuntuExpansions, self).setUp()
525
 
        self.directory = LaunchpadDirectory()
526
 
 
527
 
    def _make_factory(self, package='foo', distro='ubuntu', series=None):
528
 
        if series is None:
529
 
            path = '%s/%s' % (distro, package)
530
 
            url_suffix = '~branch/%s/%s' % (distro, package)
531
 
        else:
532
 
            path = '%s/%s/%s' % (distro, series, package)
533
 
            url_suffix = '~branch/%s/%s/%s' % (distro, series, package)
534
 
        return FakeResolveFactory(
535
 
            self, path, dict(urls=[
536
 
                'http://bazaar.launchpad.net/' + url_suffix]))
537
 
 
538
 
    def assertURL(self, expected_url, shortcut, package='foo', distro='ubuntu',
539
 
                  series=None):
540
 
        factory = self._make_factory(package=package, distro=distro,
541
 
                                     series=series)
542
 
        self.assertEqual('http://bazaar.launchpad.net/~branch/' + expected_url,
543
 
                         self.directory._resolve(shortcut, factory))
544
 
 
545
 
    # Bogus distro.
546
 
 
547
 
    def test_bogus_distro(self):
548
 
        self.assertRaises(errors.InvalidURL,
549
 
                          self.directory._resolve, 'gentoo:foo')
550
 
 
551
 
    def test_trick_bogus_distro_u(self):
552
 
        self.assertRaises(errors.InvalidURL,
553
 
                          self.directory._resolve, 'utube:foo')
554
 
 
555
 
    def test_trick_bogus_distro_d(self):
556
 
        self.assertRaises(errors.InvalidURL,
557
 
                          self.directory._resolve, 'debuntu:foo')
558
 
 
559
 
    def test_missing_ubuntu_distroseries_without_project(self):
560
 
        # Launchpad does not hold source packages for Intrepid.  Missing or
561
 
        # bogus distroseries with no project name is treated like a project.
562
 
        self.assertURL('ubuntu/intrepid', 'ubuntu:intrepid', package='intrepid')
563
 
 
564
 
    def test_missing_ubuntu_distroseries_with_project(self):
565
 
        # Launchpad does not hold source packages for Intrepid.  Missing or
566
 
        # bogus distroseries with a project name is treated like an unknown
567
 
        # series (i.e. we keep it verbatim).
568
 
        self.assertURL('ubuntu/intrepid/foo',
569
 
                       'ubuntu:intrepid/foo', series='intrepid')
570
 
 
571
 
    def test_missing_debian_distroseries(self):
572
 
        # Launchpad does not hold source packages for unstable.  Missing or
573
 
        # bogus distroseries is treated like a project.
574
 
        self.assertURL('debian/sid',
575
 
                       'debianlp:sid', package='sid', distro='debian')
576
 
 
577
 
    # Ubuntu Default distro series.
578
 
 
579
 
    def test_ubuntu_default_distroseries_expansion(self):
580
 
        self.assertURL('ubuntu/foo', 'ubuntu:foo')
581
 
 
582
 
    def test_ubuntu_natty_distroseries_expansion(self):
583
 
        self.assertURL('ubuntu/natty/foo', 'ubuntu:natty/foo', series='natty')
584
 
 
585
 
    def test_ubuntu_n_distroseries_expansion(self):
586
 
        self.assertURL('ubuntu/natty/foo', 'ubuntu:n/foo', series='natty')
587
 
 
588
 
    def test_ubuntu_maverick_distroseries_expansion(self):
589
 
        self.assertURL('ubuntu/maverick/foo', 'ubuntu:maverick/foo',
590
 
                       series='maverick')
591
 
 
592
 
    def test_ubuntu_m_distroseries_expansion(self):
593
 
        self.assertURL('ubuntu/maverick/foo', 'ubuntu:m/foo', series='maverick')
594
 
 
595
 
    def test_ubuntu_lucid_distroseries_expansion(self):
596
 
        self.assertURL('ubuntu/lucid/foo', 'ubuntu:lucid/foo', series='lucid')
597
 
 
598
 
    def test_ubuntu_l_distroseries_expansion(self):
599
 
        self.assertURL('ubuntu/lucid/foo', 'ubuntu:l/foo', series='lucid')
600
 
 
601
 
    def test_ubuntu_karmic_distroseries_expansion(self):
602
 
        self.assertURL('ubuntu/karmic/foo', 'ubuntu:karmic/foo',
603
 
                       series='karmic')
604
 
 
605
 
    def test_ubuntu_k_distroseries_expansion(self):
606
 
        self.assertURL('ubuntu/karmic/foo', 'ubuntu:k/foo', series='karmic')
607
 
 
608
 
    def test_ubuntu_jaunty_distroseries_expansion(self):
609
 
        self.assertURL('ubuntu/jaunty/foo', 'ubuntu:jaunty/foo',
610
 
                       series='jaunty')
611
 
 
612
 
    def test_ubuntu_j_distroseries_expansion(self):
613
 
        self.assertURL('ubuntu/jaunty/foo', 'ubuntu:j/foo', series='jaunty')
614
 
 
615
 
    def test_ubuntu_hardy_distroseries_expansion(self):
616
 
        self.assertURL('ubuntu/hardy/foo', 'ubuntu:hardy/foo', series='hardy')
617
 
 
618
 
    def test_ubuntu_h_distroseries_expansion(self):
619
 
        self.assertURL('ubuntu/hardy/foo', 'ubuntu:h/foo', series='hardy')
620
 
 
621
 
    def test_ubuntu_dapper_distroseries_expansion(self):
622
 
        self.assertURL('ubuntu/dapper/foo', 'ubuntu:dapper/foo',
623
 
                       series='dapper')
624
 
 
625
 
    def test_ubuntu_d_distroseries_expansion(self):
626
 
        self.assertURL('ubuntu/dapper/foo', 'ubuntu:d/foo', series='dapper')
627
 
 
628
 
    # Debian default distro series.
629
 
 
630
 
    def test_debian_default_distroseries_expansion(self):
631
 
        self.assertURL('debian/foo', 'debianlp:foo', distro='debian')
632
 
 
633
 
    def test_debian_squeeze_distroseries_expansion(self):
634
 
        self.assertURL('debian/squeeze/foo', 'debianlp:squeeze/foo',
635
 
                       distro='debian', series='squeeze')
636
 
 
637
 
    def test_debian_lenny_distroseries_expansion(self):
638
 
        self.assertURL('debian/lenny/foo', 'debianlp:lenny/foo',
639
 
                       distro='debian', series='lenny')