1
=== removed directory 'lib/canonical/launchpad/apidoc'
2
=== added directory 'lib/launchpad_loggerhead'
3
=== added file 'lib/launchpad_loggerhead/__init__.py'
4
--- lib/launchpad_loggerhead/__init__.py	1970-01-01 00:00:00 +0000
5
+++ lib/launchpad_loggerhead/__init__.py	2010-04-27 01:35:56 +0000
6
@@ -0,0 +1,1 @@
7
1
8
0
2
9
=== added file 'lib/launchpad_loggerhead/app.py'
10
--- lib/launchpad_loggerhead/app.py	1970-01-01 00:00:00 +0000
11
+++ lib/launchpad_loggerhead/app.py	2010-04-27 01:39:55 +0000
12
@@ -0,0 +1,215 @@
13
1
# Copyright 2009 Canonical Ltd.  This software is licensed under the
14
2
# GNU Affero General Public License version 3 (see the file LICENSE).
15
3
16
4
import logging
17
5
import os
18
6
import threading
19
7
import urllib
20
8
import urlparse
21
9
import xmlrpclib
22
10
23
11
from bzrlib import errors, lru_cache, urlutils
24
12
25
13
from loggerhead.apps import favicon_app, static_app
26
14
from loggerhead.apps.branch import BranchWSGIApp
27
15
28
16
from openid.extensions.sreg import SRegRequest, SRegResponse
29
17
from openid.consumer.consumer import CANCEL, Consumer, FAILURE, SUCCESS
30
18
from openid.store.memstore import MemoryStore
31
19
32
20
from paste.fileapp import DataApp
33
21
from paste.request import construct_url, parse_querystring, path_info_pop
34
22
from paste.httpexceptions import (
35
23
    HTTPMovedPermanently, HTTPNotFound, HTTPUnauthorized)
36
24
37
25
from canonical.config import config
38
26
from canonical.launchpad.xmlrpc import faults
39
27
from canonical.launchpad.webapp.vhosts import allvhosts
40
28
from lp.code.interfaces.codehosting import (
41
29
    BRANCH_TRANSPORT, LAUNCHPAD_ANONYMOUS)
42
30
from lp.codehosting.vfs import get_lp_server
43
31
from lp.codehosting.bzrutils import safe_open
44
32
45
33
robots_txt = '''\
46
34
User-agent: *
47
35
Disallow: /
48
36
'''
49
37
50
38
robots_app = DataApp(robots_txt, content_type='text/plain')
51
39
52
40
53
41
thread_transports = threading.local()
54
42
55
43
56
44
def check_fault(fault, *fault_classes):
57
45
    """Check if 'fault's faultCode matches any of 'fault_classes'.
58
46
59
47
    :param fault: An instance of `xmlrpclib.Fault`.
60
48
    :param fault_classes: Any number of `LaunchpadFault` subclasses.
61
49
    """
62
50
    for cls in fault_classes:
63
51
        if fault.faultCode == cls.error_code:
64
52
            return True
65
53
    return False
66
54
67
55
68
56
class RootApp:
69
57
70
58
    def __init__(self, session_var):
71
59
        self.graph_cache = lru_cache.LRUCache(10)
72
60
        self.branchfs = xmlrpclib.ServerProxy(
73
61
            config.codehosting.codehosting_endpoint)
74
62
        self.session_var = session_var
75
63
        self.store = MemoryStore()
76
64
        self.log = logging.getLogger('lp-loggerhead')
77
65
78
66
    def get_transports(self):
79
67
        t = getattr(thread_transports, 'transports', None)
80
68
        if t is None:
81
69
            thread_transports.transports = []
82
70
        return thread_transports.transports
83
71
84
72
    def _make_consumer(self, environ):
85
73
        """Build an OpenID `Consumer` object with standard arguments."""
86
74
        return Consumer(environ[self.session_var], self.store)
87
75
88
76
    def _begin_login(self, environ, start_response):
89
77
        """Start the process of authenticating with OpenID.
90
78
91
79
        We redirect the user to Launchpad to identify themselves, asking to be
92
80
        sent their nickname.  Launchpad will then redirect them to our +login
93
81
        page with enough information that we can then redirect them again to
94
82
        the page they were looking at, with a cookie that gives us the
95
83
        username.
96
84
        """
97
85
        openid_vhost = config.launchpad.openid_provider_vhost
98
86
        openid_request = self._make_consumer(environ).begin(
99
87
            allvhosts.configs[openid_vhost].rooturl)
100
88
        openid_request.addExtension(
101
89
            SRegRequest(required=['nickname']))
102
90
        back_to = construct_url(environ)
103
91
        raise HTTPMovedPermanently(openid_request.redirectURL(
104
92
            config.codehosting.secure_codebrowse_root,
105
93
            config.codehosting.secure_codebrowse_root + '+login/?'
106
94
            + urllib.urlencode({'back_to':back_to})))
107
95
108
96
    def _complete_login(self, environ, start_response):
109
97
        """Complete the OpenID authentication process.
110
98
111
99
        Here we handle the result of the OpenID process.  If the process
112
100
        succeeded, we record the username in the session and redirect the user
113
101
        to the page they were trying to view that triggered the login attempt.
114
102
        In the various failures cases we return a 401 Unauthorized response
115
103
        with a brief explanation of what went wrong.
116
104
        """
117
105
        query = dict(parse_querystring(environ))
118
106
        # Passing query['openid.return_to'] here is massive cheating, but
119
107
        # given we control the endpoint who cares.
120
108
        response = self._make_consumer(environ).complete(
121
109
            query, query['openid.return_to'])
122
110
        if response.status == SUCCESS:
123
111
            self.log.error('open id response: SUCCESS')
124
112
            sreg_info = SRegResponse.fromSuccessResponse(response)
125
113
            print sreg_info
126
114
            environ[self.session_var]['user'] = sreg_info['nickname']
127
115
            raise HTTPMovedPermanently(query['back_to'])
128
116
        elif response.status == FAILURE:
129
117
            self.log.error('open id response: FAILURE: %s', response.message)
130
118
            exc = HTTPUnauthorized()
131
119
            exc.explanation = response.message
132
120
            raise exc
133
121
        elif response.status == CANCEL:
134
122
            self.log.error('open id response: CANCEL')
135
123
            exc = HTTPUnauthorized()
136
124
            exc.explanation = "Authetication cancelled."
137
125
            raise exc
138
126
        else:
139
127
            self.log.error('open id response: UNKNOWN')
140
128
            exc = HTTPUnauthorized()
141
129
            exc.explanation = "Unknown OpenID response."
142
130
            raise exc
143
131
144
132
    def __call__(self, environ, start_response):
145
133
        environ['loggerhead.static.url'] = environ['SCRIPT_NAME']
146
134
        if environ['PATH_INFO'].startswith('/static/'):
147
135
            path_info_pop(environ)
148
136
            return static_app(environ, start_response)
149
137
        elif environ['PATH_INFO'] == '/favicon.ico':
150
138
            return favicon_app(environ, start_response)
151
139
        elif environ['PATH_INFO'] == '/robots.txt':
152
140
            return robots_app(environ, start_response)
153
141
        elif environ['PATH_INFO'].startswith('/+login'):
154
142
            return self._complete_login(environ, start_response)
155
143
        path = environ['PATH_INFO']
156
144
        trailingSlashCount = len(path) - len(path.rstrip('/'))
157
145
        user = environ[self.session_var].get('user', LAUNCHPAD_ANONYMOUS)
158
146
        lp_server = get_lp_server(
159
147
            user, branch_url=config.codehosting.internal_branch_by_id_root)
160
148
        lp_server.start_server()
161
149
        try:
162
150
            try:
163
151
                transport_type, info, trail = self.branchfs.translatePath(
164
152
                    user, urlutils.escape(path))
165
153
            except xmlrpclib.Fault, f:
166
154
                if check_fault(f, faults.PathTranslationError):
167
155
                    raise HTTPNotFound()
168
156
                elif check_fault(f, faults.PermissionDenied):
169
157
                    # If we're not allowed to see the branch...
170
158
                    if environ['wsgi.url_scheme'] != 'https':
171
159
                        # ... the request shouldn't have come in over http, as
172
160
                        # requests for private branches over http should be
173
161
                        # redirected to https by the dynamic rewrite script we
174
162
                        # use (which runs before this code is reached), but
175
163
                        # just in case...
176
164
                        env_copy = environ.copy()
177
165
                        env_copy['wsgi.url_scheme'] = 'https'
178
166
                        raise HTTPMovedPermanently(construct_url(env_copy))
179
167
                    elif user != LAUNCHPAD_ANONYMOUS:
180
168
                        # ... if the user is already logged in and still can't
181
169
                        # see the branch, they lose.
182
170
                        exc = HTTPUnauthorized()
183
171
                        exc.explanation = "You are logged in as %s." % user
184
172
                        raise exc
185
173
                    else:
186
174
                        # ... otherwise, lets give them a chance to log in
187
175
                        # with OpenID.
188
176
                        return self._begin_login(environ, start_response)
189
177
                else:
190
178
                    raise
191
179
            if transport_type != BRANCH_TRANSPORT:
192
180
                raise HTTPNotFound()
193
181
            trail = urlutils.unescape(trail).encode('utf-8')
194
182
            trail += trailingSlashCount * '/'
195
183
            amount_consumed = len(path) - len(trail)
196
184
            consumed = path[:amount_consumed]
197
185
            branch_name = consumed.strip('/')
198
186
            self.log.info('Using branch: %s', branch_name)
199
187
            if trail and not trail.startswith('/'):
200
188
                trail = '/' + trail
201
189
            environ['PATH_INFO'] = trail
202
190
            environ['SCRIPT_NAME'] += consumed.rstrip('/')
203
191
            branch_url = lp_server.get_url() + branch_name
204
192
            branch_link = urlparse.urljoin(
205
193
                config.codebrowse.launchpad_root, branch_name)
206
194
            cachepath = os.path.join(
207
195
                config.codebrowse.cachepath, branch_name[1:])
208
196
            if not os.path.isdir(cachepath):
209
197
                os.makedirs(cachepath)
210
198
            self.log.info('branch_url: %s', branch_url)
211
199
            try:
212
200
                bzr_branch = safe_open(
213
201
                    lp_server.get_url().strip(':/'), branch_url,
214
202
                    possible_transports=self.get_transports())
215
203
            except errors.NotBranchError, err:
216
204
                self.log.warning('Not a branch: %s', err)
217
205
                raise HTTPNotFound()
218
206
            bzr_branch.lock_read()
219
207
            try:
220
208
                view = BranchWSGIApp(
221
209
                    bzr_branch, branch_name, {'cachepath': cachepath},
222
210
                    self.graph_cache, branch_link=branch_link, served_url=None)
223
211
                return view.app(environ, start_response)
224
212
            finally:
225
213
                bzr_branch.unlock()
226
214
        finally:
227
215
            lp_server.stop_server()
228
0
216
229
=== added file 'lib/launchpad_loggerhead/debug.py'
230
--- lib/launchpad_loggerhead/debug.py	1970-01-01 00:00:00 +0000
231
+++ lib/launchpad_loggerhead/debug.py	2010-04-27 01:35:56 +0000
232
@@ -0,0 +1,120 @@
233
1
# Copyright 2009 Canonical Ltd.  This software is licensed under the
234
2
# GNU Affero General Public License version 3 (see the file LICENSE).
235
3
236
4
import thread
237
5
import time
238
6
239
7
from paste.request import construct_url
240
8
241
9
242
10
def tabulate(cells):
243
11
    """Format a list of lists of strings in a table.
244
12
245
13
    The 'cells' are centered.
246
14
247
15
    >>> print ''.join(tabulate(
248
16
    ...     [['title 1', 'title 2'],
249
17
    ...      ['short', 'rather longer']]))
250
18
     title 1     title 2
251
19
      short   rather longer
252
20
    """
253
21
    widths = {}
254
22
    for row in cells:
255
23
        for col_index, cell in enumerate(row):
256
24
            widths[col_index] = max(len(cell), widths.get(col_index, 0))
257
25
    result = []
258
26
    for row in cells:
259
27
        result_row = ''
260
28
        for col_index, cell in enumerate(row):
261
29
            result_row += cell.center(widths[col_index] + 2)
262
30
        result.append(result_row.rstrip() + '\n')
263
31
    return result
264
32
265
33
266
34
def threadpool_debug(app):
267
35
    """Wrap `app` to provide debugging information about the threadpool state.
268
36
269
37
    The returned application will serve debugging information about the state
270
38
    of the threadpool at '/thread-debug' -- but only when accessed directly,
271
39
    not when accessed through Apache.
272
40
    """
273
41
    def wrapped(environ, start_response):
274
42
        if ('HTTP_X_FORWARDED_SERVER' in environ
275
43
            or environ['PATH_INFO'] != '/thread-debug'):
276
44
            environ['lp.timestarted'] = time.time()
277
45
            return app(environ, start_response)
278
46
        threadpool = environ['paste.httpserver.thread_pool']
279
47
        start_response("200 Ok", [])
280
48
        output = [("url", "time running", "time since last activity")]
281
49
        now = time.time()
282
50
        # Because we're accessing mutable structures without locks here,
283
51
        # we're a bit cautious about things looking like we expect -- if a
284
52
        # worker doesn't seem fully set up, we just ignore it.
285
53
        for worker in threadpool.workers:
286
54
            if not hasattr(worker, 'thread_id'):
287
55
                continue
288
56
            time_started, info = threadpool.worker_tracker.get(
289
57
                worker.thread_id, (None, None))
290
58
            if time_started is not None and info is not None:
291
59
                real_time_started = info.get(
292
60
                    'lp.timestarted', time_started)
293
61
                output.append(
294
62
                    map(str,
295
63
                        (construct_url(info),
296
64
                         now - real_time_started,
297
65
                         now - time_started,)))
298
66
        return tabulate(output)
299
67
    return wrapped
300
68
301
69
302
70
def change_kill_thread_criteria(application):
303
71
    """Interfere with threadpool so that threads are killed for inactivity.
304
72
305
73
    The usual rules with paste's threadpool is that a thread that takes longer
306
74
    than 'hung_thread_limit' seconds to process a request is considered hung
307
75
    and more than 'kill_thread_limit' seconds is killed.
308
76
309
77
    Because loggerhead streams its output, how long the entire request takes
310
78
    to process depends on things like how fast the users internet connection
311
79
    is.  What we'd like to do is kill threads that don't _start_ to produce
312
80
    output for 'kill_thread_limit' seconds.
313
81
314
82
    What this class actually does is arrange things so that threads that
315
83
    produce no output for 'kill_thread_limit' are killed, because that's the
316
84
    rule Apache uses when interpreting ProxyTimeout.
317
85
    """
318
86
    def wrapped_application(environ, start_response):
319
87
        threadpool = environ['paste.httpserver.thread_pool']
320
88
        def reset_timer():
321
89
            """Make this thread safe for another 'kill_thread_limit' seconds.
322
90
323
91
            We do this by hacking the threadpool's record of when this thread
324
92
            started to pretend that it started right now.  Hacky, but it's
325
93
            enough to fool paste.httpserver.ThreadPool.kill_hung_threads and
326
94
            that's what matters.
327
95
            """
328
96
            threadpool.worker_tracker[thread.get_ident()][0] = time.time()
329
97
        def response_hook(status, response_headers, exc_info=None):
330
98
            # We reset the timer when the HTTP headers are sent...
331
99
            reset_timer()
332
100
            writer = start_response(status, response_headers, exc_info)
333
101
            def wrapped_writer(arg):
334
102
                # ... and whenever more output has been generated.
335
103
                reset_timer()
336
104
                return writer(arg)
337
105
            return wrapped_writer
338
106
        result = application(environ, response_hook)
339
107
        # WSGI allows the application to return an iterable, which could be a
340
108
        # generator that does significant processing between successive items,
341
109
        # so we should reset the timer between each item.
342
110
        #
343
111
        # This isn't really necessary as loggerhead doesn't return any
344
112
        # non-trivial iterables to the WSGI server.  But it's probably better
345
113
        # to cope with this case to avoid nasty suprises if loggerhead
346
114
        # changes.
347
115
        def reset_timer_between_items(iterable):
348
116
            for item in iterable:
349
117
                reset_timer()
350
118
                yield item
351
119
        return reset_timer_between_items(result)
352
120
    return wrapped_application
353
0
121
354
=== added file 'lib/launchpad_loggerhead/session.py'
355
--- lib/launchpad_loggerhead/session.py	1970-01-01 00:00:00 +0000
356
+++ lib/launchpad_loggerhead/session.py	2010-04-27 01:35:56 +0000
357
@@ -0,0 +1,73 @@
358
1
# Copyright 2009 Canonical Ltd.  This software is licensed under the
359
2
# GNU Affero General Public License version 3 (see the file LICENSE).
360
3
361
4
"""Simple paste-y session manager tuned for the needs of launchpad-loggerhead.
362
5
"""
363
6
364
7
import pickle
365
8
366
9
from paste.auth.cookie import AuthCookieHandler, AuthCookieSigner
367
10
368
11
369
12
class MyAuthCookieSigner(AuthCookieSigner):
370
13
    """Fix a bug in AuthCookieSigner."""
371
14
372
15
    def sign(self, content):
373
16
        # XXX 2008-01-13 Michael Hudson: paste.auth.cookie generates bogus
374
17
        # cookies when the value is long:
375
18
        # http://trac.pythonpaste.org/pythonpaste/ticket/257.  This is fixed
376
19
        # now, so when a new version is released and packaged we can remove
377
20
        # this class.
378
21
        r = AuthCookieSigner.sign(self, content)
379
22
        return r.replace('\n', '')
380
23
381
24
382
25
class SessionHandler(object):
383
26
    """Middleware that provides a cookie-based session.
384
27
385
28
    The session dict is stored, pickled (and HMACed), in a cookie, so don't
386
29
    store very much in the session!
387
30
    """
388
31
389
32
    def __init__(self, application, session_var, secret=None):
390
33
        """Initialize a SessionHandler instance.
391
34
392
35
        :param application: This is the wrapped application which will have
393
36
            access to the ``environ[session_var]`` dictionary managed by this
394
37
            middleware.
395
38
        :param session_var: The key under which to store the session
396
39
            dictionary in the environment.
397
40
        :param secret: A secret value used for signing the cookie.  If not
398
41
            supplied, a new secret will be used for each instantiation of the
399
42
            SessionHandler.
400
43
        """
401
44
        self.application = application
402
45
        self.cookie_handler = AuthCookieHandler(
403
46
            self._process, scanlist=[session_var],
404
47
            signer=MyAuthCookieSigner(secret))
405
48
        self.session_var = session_var
406
49
407
50
    def __call__(self, environ, start_response):
408
51
        # We need to put the request through the cookie handler first, so we
409
52
        # can access the validated string in the environ in `_process` below.
410
53
        return self.cookie_handler(environ, start_response)
411
54
412
55
    def _process(self, environ, start_response):
413
56
        """Process a request.
414
57
415
58
        AuthCookieHandler takes care of getting the text value of the session
416
59
        in and out of the cookie (and validating the text using HMAC) so we
417
60
        just need to convert that string to and from a real dictionary using
418
61
        pickle.
419
62
        """
420
63
        if self.session_var in environ:
421
64
            session = pickle.loads(environ[self.session_var])
422
65
        else:
423
66
            session = {}
424
67
        environ[self.session_var] = session
425
68
        def response_hook(status, response_headers, exc_info=None):
426
69
            session = environ.pop(self.session_var)
427
70
            if session:
428
71
                environ[self.session_var] = pickle.dumps(session)
429
72
            return start_response(status, response_headers, exc_info)
430
73
        return self.application(environ, response_hook)
431
0
74
432
=== added directory 'lib/launchpad_loggerhead/static'
433
=== added file 'lib/launchpad_loggerhead/static/robots.txt'
434
--- lib/launchpad_loggerhead/static/robots.txt	1970-01-01 00:00:00 +0000
435
+++ lib/launchpad_loggerhead/static/robots.txt	2010-04-27 01:35:56 +0000
436
@@ -0,0 +1,2 @@
437
1
User-agent: *
438
2
Disallow: /
439
0
3
440
=== modified file 'lib/lp/bugs/scripts/bugheat.py'
441
--- lib/lp/bugs/scripts/bugheat.py	2010-04-28 21:40:12 +0000
442
+++ lib/lp/bugs/scripts/bugheat.py	2010-04-29 14:53:44 +0000
443
@@ -90,4 +90,19 @@
444
90
            self.bug.date_last_updated.replace(tzinfo=None)).days
90
            self.bug.date_last_updated.replace(tzinfo=None)).days
445
91
        total_heat = int(total_heat * (0.99 ** days))
91
        total_heat = int(total_heat * (0.99 ** days))
446
92
92
448
93
        return total_heat
93
        if days > 0:
449
94
            # Bug heat increases by a quarter of the maximum bug heat divided
450
95
            # by the number of days since the bug's creation date.
451
96
            days_since_last_activity = (
452
97
                datetime.utcnow() -
453
98
                max(self.bug.date_last_updated.replace(tzinfo=None),
454
99
                    self.bug.date_last_message.replace(tzinfo=None))).days
455
100
            days_since_created = (
456
101
                datetime.utcnow() - self.bug.datecreated.replace(tzinfo=None)).days
457
102
            max_heat = max(
458
103
                task.target.max_bug_heat for task in self.bug.bugtasks)
459
104
            if max_heat is not None and days_since_created > 0:
460
105
                total_heat = total_heat + (max_heat * 0.25 / days_since_created)
461
106
462
107
        return int(total_heat)
463
108
464
94
109
465
=== modified file 'lib/lp/bugs/scripts/tests/test_bugheat.py'
466
--- lib/lp/bugs/scripts/tests/test_bugheat.py	2010-04-28 21:40:12 +0000
467
+++ lib/lp/bugs/scripts/tests/test_bugheat.py	2010-04-29 14:53:44 +0000
468
@@ -7,7 +7,7 @@
469
7
7
470
8
import unittest
8
import unittest
471
9
9
473
10
from datetime import timedelta
10
from datetime import datetime, timedelta
474
11
11
475
12
from canonical.testing import LaunchpadZopelessLayer
12
from canonical.testing import LaunchpadZopelessLayer
476
13
13
477
@@ -15,6 +15,9 @@
478
15
from lp.bugs.scripts.bugheat import BugHeatCalculator, BugHeatConstants
15
from lp.bugs.scripts.bugheat import BugHeatCalculator, BugHeatConstants
479
16
from lp.testing import TestCaseWithFactory
16
from lp.testing import TestCaseWithFactory
480
17
17
481
18
from zope.security.proxy import removeSecurityProxy
482
19
483
20
484
18
class TestBugHeatCalculator(TestCaseWithFactory):
21
class TestBugHeatCalculator(TestCaseWithFactory):
485
19
    """Tests for the BugHeatCalculator class."""
22
    """Tests for the BugHeatCalculator class."""
486
20
    # If you change the way that bug heat is calculated, remember to update
23
    # If you change the way that bug heat is calculated, remember to update
487
@@ -231,6 +234,23 @@
488
231
            "Expected bug heat did not match actual bug heat. "
234
            "Expected bug heat did not match actual bug heat. "
489
232
            "Expected %s, got %s" % (expected, heat))
235
            "Expected %s, got %s" % (expected, heat))
490
233
236
491
237
    def test_getBugHeat_activity(self):
492
238
        # Bug heat increases by a quarter of the maximum bug heat divided by
493
239
        # the number of days between the bug's creating and its last activity.
494
240
        active_bug = removeSecurityProxy(self.factory.makeBug())
495
241
        fresh_heat = BugHeatCalculator(active_bug).getBugHeat()
496
242
        active_bug.date_last_updated = (
497
243
            active_bug.date_last_updated - timedelta(days=10))
498
244
        active_bug.datecreated = (active_bug.datecreated - timedelta(days=20))
499
245
        active_bug.default_bugtask.target.setMaxBugHeat(100)
500
246
        expected = int((fresh_heat * (0.99 ** 20)) + (100 * 0.25 / 20))
501
247
        heat = BugHeatCalculator(active_bug).getBugHeat()
502
248
        self.assertEqual(
503
249
            expected, heat,
504
250
            "Expected bug heat did not match actual bug heat. "
505
251
            "Expected %s, got %s" % (expected, heat))
506
252
507
253
508
234
254
509
235
def test_suite():
255
def test_suite():
510
236
    return unittest.TestLoader().loadTestsFromName(__name__)
256
    return unittest.TestLoader().loadTestsFromName(__name__)
511
237
257
512
=== added file 'lib/lp/code/model/tests/test_sourcepackagerecipe.py'
513
--- lib/lp/code/model/tests/test_sourcepackagerecipe.py	1970-01-01 00:00:00 +0000
514
+++ lib/lp/code/model/tests/test_sourcepackagerecipe.py	2010-04-20 03:27:10 +0000
515
@@ -0,0 +1,511 @@
516
1
# Copyright 2009, 2010 Canonical Ltd.  This software is licensed under the
517
2
# GNU Affero General Public License version 3 (see the file LICENSE).
518
3
519
4
"""Tests for the SourcePackageRecipe content type."""
520
5
521
6
from __future__ import with_statement
522
7
523
8
__metaclass__ = type
524
9
525
10
from datetime import datetime
526
11
import textwrap
527
12
import unittest
528
13
529
14
from bzrlib.plugins.builder.recipe import RecipeParser
530
15
531
16
from pytz import UTC
532
17
from storm.locals import Store
533
18
534
19
from zope.component import getUtility
535
20
from zope.security.interfaces import Unauthorized
536
21
from zope.security.proxy import removeSecurityProxy
537
22
538
23
from canonical.testing.layers import DatabaseFunctionalLayer
539
24
540
25
from canonical.launchpad.webapp.authorization import check_permission
541
26
from lp.archiveuploader.permission import (
542
27
    ArchiveDisabled, CannotUploadToArchive, InvalidPocketForPPA)
543
28
from lp.buildmaster.interfaces.buildqueue import IBuildQueue
544
29
from lp.buildmaster.model.buildqueue import BuildQueue
545
30
from lp.code.interfaces.sourcepackagerecipe import (
546
31
    ForbiddenInstruction, ISourcePackageRecipe, ISourcePackageRecipeSource,
547
32
    TooNewRecipeFormat)
548
33
from lp.code.interfaces.sourcepackagerecipebuild import (
549
34
    ISourcePackageRecipeBuild, ISourcePackageRecipeBuildJob)
550
35
from lp.code.model.sourcepackagerecipebuild import (
551
36
    SourcePackageRecipeBuildJob)
552
37
from lp.code.model.sourcepackagerecipe import (
553
38
    NonPPABuildRequest)
554
39
from lp.registry.interfaces.pocket import PackagePublishingPocket
555
40
from lp.services.job.interfaces.job import (
556
41
    IJob, JobStatus)
557
42
from lp.soyuz.interfaces.archive import ArchivePurpose
558
43
from lp.testing import (
559
44
    login_person, person_logged_in, TestCaseWithFactory)
560
45
561
46
class TestSourcePackageRecipe(TestCaseWithFactory):
562
47
    """Tests for `SourcePackageRecipe` objects."""
563
48
564
49
    layer = DatabaseFunctionalLayer
565
50
566
51
    def makeSourcePackageRecipeFromBuilderRecipe(self, builder_recipe):
567
52
        """Make a SourcePackageRecipe from a recipe with arbitrary other data.
568
53
        """
569
54
        registrant = self.factory.makePerson()
570
55
        owner = self.factory.makeTeam(owner=registrant)
571
56
        distroseries = self.factory.makeDistroSeries()
572
57
        sourcepackagename = self.factory.makeSourcePackageName()
573
58
        name = self.factory.getUniqueString(u'recipe-name')
574
59
        description = self.factory.getUniqueString(u'recipe-description')
575
60
        return getUtility(ISourcePackageRecipeSource).new(
576
61
            registrant=registrant, owner=owner, distroseries=[distroseries],
577
62
            sourcepackagename=sourcepackagename, name=name,
578
63
            description=description, builder_recipe=builder_recipe)
579
64
580
65
    def test_creation(self):
581
66
        # The metadata supplied when a SourcePackageRecipe is created is
582
67
        # present on the new object.
583
68
        registrant = self.factory.makePerson()
584
69
        owner = self.factory.makeTeam(owner=registrant)
585
70
        distroseries = self.factory.makeDistroSeries()
586
71
        sourcepackagename = self.factory.makeSourcePackageName()
587
72
        name = self.factory.getUniqueString(u'recipe-name')
588
73
        description = self.factory.getUniqueString(u'recipe-description')
589
74
        builder_recipe = self.factory.makeRecipe()
590
75
        recipe = getUtility(ISourcePackageRecipeSource).new(
591
76
            registrant=registrant, owner=owner, distroseries=[distroseries],
592
77
            sourcepackagename=sourcepackagename, name=name,
593
78
            description=description, builder_recipe=builder_recipe)
594
79
        self.assertEquals(
595
80
            (registrant, owner, set([distroseries]), sourcepackagename, name),
596
81
            (recipe.registrant, recipe.owner, set(recipe.distroseries),
597
82
             recipe.sourcepackagename, recipe.name))
598
83
599
84
    def test_source_implements_interface(self):
600
85
        # The SourcePackageRecipe class implements ISourcePackageRecipeSource.
601
86
        self.assertProvides(
602
87
            getUtility(ISourcePackageRecipeSource),
603
88
            ISourcePackageRecipeSource)
604
89
605
90
    def test_recipe_implements_interface(self):
606
91
        # SourcePackageRecipe objects implement ISourcePackageRecipe.
607
92
        recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
608
93
            self.factory.makeRecipe())
609
94
        self.assertProvides(recipe, ISourcePackageRecipe)
610
95
611
96
    def test_base_branch(self):
612
97
        # When a recipe is created, we can access its base branch.
613
98
        branch = self.factory.makeAnyBranch()
614
99
        builder_recipe = self.factory.makeRecipe(branch)
615
100
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
616
101
            builder_recipe)
617
102
        self.assertEquals(branch, sp_recipe.base_branch)
618
103
619
104
    def test_branch_links_created(self):
620
105
        # When a recipe is created, we can query it for links to the branch
621
106
        # it references.
622
107
        branch = self.factory.makeAnyBranch()
623
108
        builder_recipe = self.factory.makeRecipe(branch)
624
109
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
625
110
            builder_recipe)
626
111
        self.assertEquals([branch], list(sp_recipe.getReferencedBranches()))
627
112
628
113
    def test_multiple_branch_links_created(self):
629
114
        # If a recipe links to more than one branch, getReferencedBranches()
630
115
        # returns all of them.
631
116
        branch1 = self.factory.makeAnyBranch()
632
117
        branch2 = self.factory.makeAnyBranch()
633
118
        builder_recipe = self.factory.makeRecipe(branch1, branch2)
634
119
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
635
120
            builder_recipe)
636
121
        self.assertEquals(
637
122
            sorted([branch1, branch2]),
638
123
            sorted(sp_recipe.getReferencedBranches()))
639
124
640
125
    def test_random_user_cant_edit(self):
641
126
        # An arbitrary user can't set attributes.
642
127
        branch1 = self.factory.makeAnyBranch()
643
128
        builder_recipe1 = self.factory.makeRecipe(branch1)
644
129
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
645
130
            builder_recipe1)
646
131
        branch2 = self.factory.makeAnyBranch()
647
132
        builder_recipe2 = self.factory.makeRecipe(branch2)
648
133
        login_person(self.factory.makePerson())
649
134
        self.assertRaises(
650
135
            Unauthorized, setattr, sp_recipe, 'builder_recipe',
651
136
            builder_recipe2)
652
137
653
138
    def test_set_recipe_text_resets_branch_references(self):
654
139
        # When the recipe_text is replaced, getReferencedBranches returns
655
140
        # (only) the branches referenced by the new recipe.
656
141
        branch1 = self.factory.makeAnyBranch()
657
142
        builder_recipe1 = self.factory.makeRecipe(branch1)
658
143
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
659
144
            builder_recipe1)
660
145
        branch2 = self.factory.makeAnyBranch()
661
146
        builder_recipe2 = self.factory.makeRecipe(branch2)
662
147
        login_person(sp_recipe.owner.teamowner)
663
148
        #import pdb; pdb.set_trace()
664
149
        sp_recipe.builder_recipe = builder_recipe2
665
150
        self.assertEquals([branch2], list(sp_recipe.getReferencedBranches()))
666
151
667
152
    def test_rejects_run_command(self):
668
153
        recipe_text = '''\
669
154
        # bzr-builder format 0.2 deb-version 0.1-{revno}
670
155
        %(base)s
671
156
        run touch test
672
157
        ''' % dict(base=self.factory.makeAnyBranch().bzr_identity)
673
158
        parser = RecipeParser(textwrap.dedent(recipe_text))
674
159
        builder_recipe = parser.parse()
675
160
        self.assertRaises(
676
161
            ForbiddenInstruction,
677
162
            self.makeSourcePackageRecipeFromBuilderRecipe, builder_recipe)
678
163
679
164
    def test_run_rejected_without_mangling_recipe(self):
680
165
        branch1 = self.factory.makeAnyBranch()
681
166
        builder_recipe1 = self.factory.makeRecipe(branch1)
682
167
        sp_recipe = self.makeSourcePackageRecipeFromBuilderRecipe(
683
168
            builder_recipe1)
684
169
        recipe_text = '''\
685
170
        # bzr-builder format 0.2 deb-version 0.1-{revno}
686
171
        %(base)s
687
172
        run touch test
688
173
        ''' % dict(base=self.factory.makeAnyBranch().bzr_identity)
689
174
        parser = RecipeParser(textwrap.dedent(recipe_text))
690
175
        builder_recipe2 = parser.parse()
691
176
        login_person(sp_recipe.owner.teamowner)
692
177
        self.assertRaises(
693
178
            ForbiddenInstruction, setattr, sp_recipe, 'builder_recipe',
694
179
            builder_recipe2)
695
180
        self.assertEquals([branch1], list(sp_recipe.getReferencedBranches()))
696
181
697
182
    def test_reject_newer_formats(self):
698
183
        builder_recipe = self.factory.makeRecipe()
699
184
        builder_recipe.format = 0.3
700
185
        self.assertRaises(
701
186
            TooNewRecipeFormat,
702
187
            self.makeSourcePackageRecipeFromBuilderRecipe, builder_recipe)
703
188
704
189
    def test_requestBuild(self):
705
190
        recipe = self.factory.makeSourcePackageRecipe()
706
191
        (distroseries,) = list(recipe.distroseries)
707
192
        ppa = self.factory.makeArchive()
708
193
        build = recipe.requestBuild(ppa, ppa.owner, distroseries,
709
194
                PackagePublishingPocket.RELEASE)
710
195
        self.assertProvides(build, ISourcePackageRecipeBuild)
711
196
        self.assertEqual(build.archive, ppa)
712
197
        self.assertEqual(build.distroseries, distroseries)
713
198
        self.assertEqual(build.requester, ppa.owner)
714
199
        store = Store.of(build)
715
200
        store.flush()
716
201
        build_job = store.find(SourcePackageRecipeBuildJob,
717
202
                SourcePackageRecipeBuildJob.build_id==build.id).one()
718
203
        self.assertProvides(build_job, ISourcePackageRecipeBuildJob)
719
204
        self.assertTrue(build_job.virtualized)
720
205
        job = build_job.job
721
206
        self.assertProvides(job, IJob)
722
207
        self.assertEquals(job.status, JobStatus.WAITING)
723
208
        build_queue = store.find(BuildQueue, BuildQueue.job==job.id).one()
724
209
        self.assertProvides(build_queue, IBuildQueue)
725
210
        self.assertTrue(build_queue.virtualized)
726
211
727
212
    def test_requestBuildRejectsNotPPA(self):
728
213
        recipe = self.factory.makeSourcePackageRecipe()
729
214
        not_ppa = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY)
730
215
        (distroseries,) = list(recipe.distroseries)
731
216
        self.assertRaises(NonPPABuildRequest, recipe.requestBuild, not_ppa,
732
217
                not_ppa.owner, distroseries, PackagePublishingPocket.RELEASE)
733
218
734
219
    def test_requestBuildRejectsNoPermission(self):
735
220
        recipe = self.factory.makeSourcePackageRecipe()
736
221
        ppa = self.factory.makeArchive()
737
222
        requester = self.factory.makePerson()
738
223
        (distroseries,) = list(recipe.distroseries)
739
224
        self.assertRaises(CannotUploadToArchive, recipe.requestBuild, ppa,
740
225
                requester, distroseries, PackagePublishingPocket.RELEASE)
741
226
742
227
    def test_requestBuildRejectsInvalidPocket(self):
743
228
        recipe = self.factory.makeSourcePackageRecipe()
744
229
        ppa = self.factory.makeArchive()
745
230
        (distroseries,) = list(recipe.distroseries)
746
231
        self.assertRaises(InvalidPocketForPPA, recipe.requestBuild, ppa,
747
232
                ppa.owner, distroseries, PackagePublishingPocket.BACKPORTS)
748
233
749
234
    def test_requestBuildRejectsDisabledArchive(self):
750
235
        recipe = self.factory.makeSourcePackageRecipe()
751
236
        ppa = self.factory.makeArchive()
752
237
        removeSecurityProxy(ppa).disable()
753
238
        (distroseries,) = list(recipe.distroseries)
754
239
        self.assertRaises(ArchiveDisabled, recipe.requestBuild, ppa,
755
240
                ppa.owner, distroseries, PackagePublishingPocket.RELEASE)
756
241
757
242
    def test_sourcepackagerecipe_description(self):
758
243
        """Ensure that the SourcePackageRecipe has a proper description."""
759
244
        description = u'The whoozits and whatzits.'
760
245
        source_package_recipe = self.factory.makeSourcePackageRecipe(
761
246
            description=description)
762
247
        self.assertEqual(description, source_package_recipe.description)
763
248
764
249
    def test_distroseries(self):
765
250
        """Test that the distroseries behaves as a set."""
766
251
        recipe = self.factory.makeSourcePackageRecipe()
767
252
        distroseries = self.factory.makeDistroSeries()
768
253
        (old_distroseries,) = recipe.distroseries
769
254
        recipe.distroseries.add(distroseries)
770
255
        self.assertEqual(
771
256
            set([distroseries, old_distroseries]), set(recipe.distroseries))
772
257
        recipe.distroseries.remove(distroseries)
773
258
        self.assertEqual([old_distroseries], list(recipe.distroseries))
774
259
        recipe.distroseries.clear()
775
260
        self.assertEqual([], list(recipe.distroseries))
776
261
777
262
    def test_build_daily(self):
778
263
        """Test that build_daily behaves as a bool."""
779
264
        recipe = self.factory.makeSourcePackageRecipe()
780
265
        self.assertFalse(recipe.build_daily)
781
266
        login_person(recipe.owner)
782
267
        recipe.build_daily = True
783
268
        self.assertTrue(recipe.build_daily)
784
269
785
270
    def test_view_public(self):
786
271
        """Anyone can view a recipe with public branches."""
787
272
        owner = self.factory.makePerson()
788
273
        branch = self.factory.makeAnyBranch(owner=owner)
789
274
        with person_logged_in(owner):
790
275
            recipe = self.factory.makeSourcePackageRecipe(branches=[branch])
791
276
            self.assertTrue(check_permission('launchpad.View', recipe))
792
277
        with person_logged_in(self.factory.makePerson()):
793
278
            self.assertTrue(check_permission('launchpad.View', recipe))
794
279
        self.assertTrue(check_permission('launchpad.View', recipe))
795
280
796
281
    def test_view_private(self):
797
282
        """Recipes with private branches are restricted."""
798
283
        owner = self.factory.makePerson()
799
284
        branch = self.factory.makeAnyBranch(owner=owner, private=True)
800
285
        with person_logged_in(owner):
801
286
            recipe = self.factory.makeSourcePackageRecipe(branches=[branch])
802
287
            self.assertTrue(check_permission('launchpad.View', recipe))
803
288
        with person_logged_in(self.factory.makePerson()):
804
289
            self.assertFalse(check_permission('launchpad.View', recipe))
805
290
        self.assertFalse(check_permission('launchpad.View', recipe))
806
291
807
292
    def test_edit(self):
808
293
        """Only the owner can edit a sourcepackagerecipe."""
809
294
        recipe = self.factory.makeSourcePackageRecipe()
810
295
        self.assertFalse(check_permission('launchpad.Edit', recipe))
811
296
        with person_logged_in(self.factory.makePerson()):
812
297
            self.assertFalse(check_permission('launchpad.Edit', recipe))
813
298
        with person_logged_in(recipe.owner):
814
299
            self.assertTrue(check_permission('launchpad.Edit', recipe))
815
300
816
301
    def test_destroySelf(self):
817
302
        """Should destroy associated builds, distroseries, etc."""
818
303
        # Recipe should have at least one datainstruction.
819
304
        branches = [self.factory.makeBranch() for count in range(2)]
820
305
        recipe = self.factory.makeSourcePackageRecipe(branches=branches)
821
306
        pending_build = self.factory.makeSourcePackageRecipeBuild(
822
307
            recipe=recipe)
823
308
        self.factory.makeSourcePackageRecipeBuildJob(
824
309
            recipe_build=pending_build)
825
310
        past_build = self.factory.makeSourcePackageRecipeBuild(
826
311
            recipe=recipe)
827
312
        self.factory.makeSourcePackageRecipeBuildJob(
828
313
            recipe_build=past_build)
829
314
        removeSecurityProxy(past_build).datebuilt = datetime.now(UTC)
830
315
        recipe.destroySelf()
831
316
        # Show no database constraints were violated
832
317
        Store.of(recipe).flush()
833
318
834
319
835
320
class TestRecipeBranchRoundTripping(TestCaseWithFactory):
836
321
837
322
    layer = DatabaseFunctionalLayer
838
323
839
324
    def setUp(self):
840
325
        super(TestRecipeBranchRoundTripping, self).setUp()
841
326
        self.base_branch = self.factory.makeAnyBranch()
842
327
        self.nested_branch = self.factory.makeAnyBranch()
843
328
        self.merged_branch = self.factory.makeAnyBranch()
844
329
        self.branch_identities = {
845
330
            'base': self.base_branch.bzr_identity,
846
331
            'nested': self.nested_branch.bzr_identity,
847
332
            'merged': self.merged_branch.bzr_identity,
848
333
            }
849
334
850
335
    def get_recipe(self, recipe_text):
851
336
        builder_recipe = RecipeParser(textwrap.dedent(recipe_text)).parse()
852
337
        registrant = self.factory.makePerson()
853
338
        owner = self.factory.makeTeam(owner=registrant)
854
339
        distroseries = self.factory.makeDistroSeries()
855
340
        sourcepackagename = self.factory.makeSourcePackageName()
856
341
        name = self.factory.getUniqueString(u'recipe-name')
857
342
        description = self.factory.getUniqueString(u'recipe-description')
858
343
        recipe = getUtility(ISourcePackageRecipeSource).new(
859
344
            registrant=registrant, owner=owner, distroseries=[distroseries],
860
345
            sourcepackagename=sourcepackagename, name=name,
861
346
            description=description, builder_recipe=builder_recipe)
862
347
        return recipe.builder_recipe
863
348
864
349
    def check_base_recipe_branch(self, branch, url, revspec=None,
865
350
            num_child_branches=0, revid=None, deb_version=None):
866
351
        self.check_recipe_branch(branch, None, url, revspec=revspec,
867
352
                num_child_branches=num_child_branches, revid=revid)
868
353
        self.assertEqual(deb_version, branch.deb_version)
869
354
870
355
    def check_recipe_branch(self, branch, name, url, revspec=None,
871
356
            num_child_branches=0, revid=None):
872
357
        self.assertEqual(name, branch.name)
873
358
        self.assertEqual(url, branch.url)
874
359
        self.assertEqual(revspec, branch.revspec)
875
360
        self.assertEqual(revid, branch.revid)
876
361
        self.assertEqual(num_child_branches, len(branch.child_branches))
877
362
878
363
    def test_builds_simplest_recipe(self):
879
364
        recipe_text = '''\
880
365
        # bzr-builder format 0.2 deb-version 0.1-{revno}
881
366
        %(base)s
882
367
        ''' % self.branch_identities
883
368
        base_branch = self.get_recipe(recipe_text)
884
369
        self.check_base_recipe_branch(
885
370
            base_branch, self.base_branch.bzr_identity,
886
371
            deb_version='0.1-{revno}')
887
372
888
373
    def test_builds_recipe_with_merge(self):
889
374
        recipe_text = '''\
890
375
        # bzr-builder format 0.2 deb-version 0.1-{revno}
891
376
        %(base)s
892
377
        merge bar %(merged)s
893
378
        ''' % self.branch_identities
894
379
        base_branch = self.get_recipe(recipe_text)
895
380
        self.check_base_recipe_branch(
896
381
            base_branch, self.base_branch.bzr_identity, num_child_branches=1,
897
382
            deb_version='0.1-{revno}')
898
383
        child_branch, location = base_branch.child_branches[0].as_tuple()
899
384
        self.assertEqual(None, location)
900
385
        self.check_recipe_branch(
901
386
            child_branch, "bar", self.merged_branch.bzr_identity)
902
387
903
388
    def test_builds_recipe_with_nest(self):
904
389
        recipe_text = '''\
905
390
        # bzr-builder format 0.2 deb-version 0.1-{revno}
906
391
        %(base)s
907
392
        nest bar %(nested)s baz
908
393
        ''' % self.branch_identities
909
394
        base_branch = self.get_recipe(recipe_text)
910
395
        self.check_base_recipe_branch(
911
396
            base_branch, self.base_branch.bzr_identity, num_child_branches=1,
912
397
            deb_version='0.1-{revno}')
913
398
        child_branch, location = base_branch.child_branches[0].as_tuple()
914
399
        self.assertEqual("baz", location)
915
400
        self.check_recipe_branch(
916
401
            child_branch, "bar", self.nested_branch.bzr_identity)
917
402
918
403
    def test_builds_recipe_with_nest_then_merge(self):
919
404
        recipe_text = '''\
920
405
        # bzr-builder format 0.2 deb-version 0.1-{revno}
921
406
        %(base)s
922
407
        nest bar %(nested)s baz
923
408
        merge zam %(merged)s
924
409
        ''' % self.branch_identities
925
410
        base_branch = self.get_recipe(recipe_text)
926
411
        self.check_base_recipe_branch(
927
412
            base_branch, self.base_branch.bzr_identity, num_child_branches=2,
928
413
            deb_version='0.1-{revno}')
929
414
        child_branch, location = base_branch.child_branches[0].as_tuple()
930
415
        self.assertEqual("baz", location)
931
416
        self.check_recipe_branch(
932
417
            child_branch, "bar", self.nested_branch.bzr_identity)
933
418
        child_branch, location = base_branch.child_branches[1].as_tuple()
934
419
        self.assertEqual(None, location)
935
420
        self.check_recipe_branch(
936
421
            child_branch, "zam", self.merged_branch.bzr_identity)
937
422
938
423
    def test_builds_recipe_with_merge_then_nest(self):
939
424
        recipe_text = '''\
940
425
        # bzr-builder format 0.2 deb-version 0.1-{revno}
941
426
        %(base)s
942
427
        merge zam %(merged)s
943
428
        nest bar %(nested)s baz
944
429
        ''' % self.branch_identities
945
430
        base_branch = self.get_recipe(recipe_text)
946
431
        self.check_base_recipe_branch(
947
432
            base_branch, self.base_branch.bzr_identity, num_child_branches=2,
948
433
            deb_version='0.1-{revno}')
949
434
        child_branch, location = base_branch.child_branches[0].as_tuple()
950
435
        self.assertEqual(None, location)
951
436
        self.check_recipe_branch(
952
437
            child_branch, "zam", self.merged_branch.bzr_identity)
953
438
        child_branch, location = base_branch.child_branches[1].as_tuple()
954
439
        self.assertEqual("baz", location)
955
440
        self.check_recipe_branch(
956
441
            child_branch, "bar", self.nested_branch.bzr_identity)
957
442
958
443
    def test_builds_a_merge_in_to_a_nest(self):
959
444
        recipe_text = '''\
960
445
        # bzr-builder format 0.2 deb-version 0.1-{revno}
961
446
        %(base)s
962
447
        nest bar %(nested)s baz
963
448
          merge zam %(merged)s
964
449
        ''' % self.branch_identities
965
450
        base_branch = self.get_recipe(recipe_text)
966
451
        self.check_base_recipe_branch(
967
452
            base_branch, self.base_branch.bzr_identity, num_child_branches=1,
968
453
            deb_version='0.1-{revno}')
969
454
        child_branch, location = base_branch.child_branches[0].as_tuple()
970
455
        self.assertEqual("baz", location)
971
456
        self.check_recipe_branch(
972
457
            child_branch, "bar", self.nested_branch.bzr_identity,
973
458
            num_child_branches=1)
974
459
        child_branch, location = child_branch.child_branches[0].as_tuple()
975
460
        self.assertEqual(None, location)
976
461
        self.check_recipe_branch(
977
462
            child_branch, "zam", self.merged_branch.bzr_identity)
978
463
979
464
    def tests_builds_nest_into_a_nest(self):
980
465
        nested2 = self.factory.makeAnyBranch()
981
466
        self.branch_identities['nested2'] = nested2.bzr_identity
982
467
        recipe_text = '''\
983
468
        # bzr-builder format 0.2 deb-version 0.1-{revno}
984
469
        %(base)s
985
470
        nest bar %(nested)s baz
986
471
          nest zam %(nested2)s zoo
987
472
        ''' % self.branch_identities
988
473
        base_branch = self.get_recipe(recipe_text)
989
474
        self.check_base_recipe_branch(
990
475
            base_branch, self.base_branch.bzr_identity, num_child_branches=1,
991
476
            deb_version='0.1-{revno}')
992
477
        child_branch, location = base_branch.child_branches[0].as_tuple()
993
478
        self.assertEqual("baz", location)
994
479
        self.check_recipe_branch(
995
480
            child_branch, "bar", self.nested_branch.bzr_identity,
996
481
            num_child_branches=1)
997
482
        child_branch, location = child_branch.child_branches[0].as_tuple()
998
483
        self.assertEqual("zoo", location)
999
484
        self.check_recipe_branch(child_branch, "zam", nested2.bzr_identity)
1000
485
1001
486
    def tests_builds_recipe_with_revspecs(self):
1002
487
        recipe_text = '''\
1003
488
        # bzr-builder format 0.2 deb-version 0.1-{revno}
1004
489
        %(base)s revid:a
1005
490
        nest bar %(nested)s baz tag:b
1006
491
        merge zam %(merged)s 2
1007
492
        ''' % self.branch_identities
1008
493
        base_branch = self.get_recipe(recipe_text)
1009
494
        self.check_base_recipe_branch(
1010
495
            base_branch, self.base_branch.bzr_identity, num_child_branches=2,
1011
496
            revspec="revid:a", deb_version='0.1-{revno}')
1012
497
        instruction = base_branch.child_branches[0]
1013
498
        child_branch = instruction.recipe_branch
1014
499
        location = instruction.nest_path
1015
500
        self.assertEqual("baz", location)
1016
501
        self.check_recipe_branch(
1017
502
            child_branch, "bar", self.nested_branch.bzr_identity,
1018
503
            revspec="tag:b")
1019
504
        child_branch, location = base_branch.child_branches[1].as_tuple()
1020
505
        self.assertEqual(None, location)
1021
506
        self.check_recipe_branch(
1022
507
            child_branch, "zam", self.merged_branch.bzr_identity, revspec="2")
1023
508
1024
509
1025
510
def test_suite():
1026
511
    return unittest.TestLoader().loadTestsFromName(__name__)
Reviewer	Review Type	Date Requested	Status
Michael Nelson (community)	code	2010-04-22	Approve on 2010-04-22
Review via email: mp+23921@code.launchpad.net