Merge lp:~wallyworld/launchpad/person-mergequeue-listview into lp:launchpad/db-devel

[Ian Booth]

Add person merge queue listing functionality. Work in progress merge queue development.

This branch delivers functionality for the merge queue development project. It adds a person merge queue list view and associated model functionality.

= Implementation =

The usual suspects were developed:
- view implementation class
- page template
- zcml changes

To supply data for the view, an IBranchMergeQueueCollection implementation was developed. The implementation is similar to IBranchCollection. A key difference is that the main collection getter, in this case getMergeQueues(), returns a list() rather than a ResultSet(). This is due to how the filtering is done in the VisibleBranchMergeQueueCollection subclass - it's done by iterating over the queue branches in memory rather than as a Storm SQL query. The required query will be non-trivial and can be implemented during another coding iteration if required. The IBranchMergeQueueCollection implementation doesn't have any search() APIs yet - this can be added later if required.

The merge queue list view shows:
- queue name
- queue size
- queue branches

NB the queue size is hard coded pending the required API being developed for IBranchMergeQueue

The menu to access the merge queue list is including alongside the other person branch menu links.

A feature flag is used to hide this functionality as the whole development effort is still WIP. This branch is sufficiently complete in what it delivers and needs to allow collaboration between separate development efforts.

= Screenshot =

Here's a screenshot of the list page:

http://people.canonical.com/~ianb/mergequeuelist.png

= Tests =

bin/test -vvt test_branchmergequeuecollection
bin/test -vvt test_branchmergequeuelisting

= Launchpad lint =

Checking for conflicts and issues in changed files.

Linting changed files:
  setup.py
  versions.cfg
  lib/lp/code/configure.zcml
  lib/lp/code/browser/branch.py
  lib/lp/code/browser/branchlisting.py
  lib/lp/code/browser/branchmergequeue.py
  lib/lp/code/browser/branchmergequeuelisting.py
  lib/lp/code/browser/configure.zcml
  lib/lp/code/browser/tests/test_branchmergequeue.py
  lib/lp/code/browser/tests/test_branchmergequeuelisting.py
  lib/lp/code/interfaces/branchmergequeue.py
  lib/lp/code/interfaces/branchmergequeuecollection.py
  lib/lp/code/model/branchmergequeue.py
  lib/lp/code/model/branchmergequeuecollection.py
  lib/lp/code/model/tests/test_branchmergequeuecollection.py
  lib/lp/code/templates/branch-pending-merges.pt
  lib/lp/code/templates/branchmergequeue-index.pt
  lib/lp/code/templates/branchmergequeue-listing.pt
  lib/lp/code/templates/branchmergequeue-macros.pt
  lib/lp/code/templates/person-codesummary.pt
  lib/lp/testing/__init__.py
  lib/lp/testing/factory.py

./setup.py
     131: E202 whitespace before ']'
./lib/lp/testing/__init__.py
     129: 'anonymous_logged_in' imported but unused
     129: 'with_anonymous_login' imported but unused
     129: 'is_logged_in' imported but unused
     148: 'launchpadlib_for' imported but unused
     148: 'launchpadlib_credentials_for' imported but unused
     129: 'person_logged_in' imported but unused
     148: 'oauth_access_token_for' imported but unused
     129: 'login_celebrity' imported but unused
     129: 'with_celebrity_logged_in' imported but unused
     147: 'test_tales' imported but unused
     129: 'celebrity_logged_in' imported but unused
     129: 'run_with_login' imported but unused
     129: 'with_person_logged_in' imported but unused
     129: 'login_team' imported but unused
     129: 'login_person' imported but unused
     129: 'login_as' imported but unused
     429: E301 expected 1 blank line, found 0
     861: E301 expected 1 blank line, found 0
     887: E302 expected 2 blank lines, found 1
     963: E302 expected 2 blank lines, found 1

Process finished with exit code 0

[Ian Booth (wallyworld)]

Adding back comments from old incorrect merge proposal:

SteveK wrote:

Hi Ian,

Firstly, thanks for this awesome work! I've been looking forward to Merge Queues for a while.

I have some comments below:

* 1,500 lines? Why!? I'd suggest in future you look at splitting up work into two separate branches for plumbing and browser code, for example.
* import with_statement isn't needed any more, we're on Python 2.6!
* I'd suggest you run the import formatter over your branch.
* Why use Star Wars names in the tests, I'd prefer descriptive names, such as self.branch_owner, which is less distracting.
* You should use XXX, rather than TODO, and file a bug per the XXX Policy.
* getUtility can be imported from zope.component directly, and indeed you mostly are, except in one place.
* Investigate usage of IMasterStore, rather than getUtility(IStoreSelector), which is deprecated-ish
* You're adding BeautifulSoup and soupmatchers to setup.py and versions.cfg, I'd suggest that get split out into an earlier branch so you can be certain they are available before landing this one.

[Ian Booth (wallyworld)]

Hi Steve

Thanks for the review.

>
> Firstly, thanks for this awesome work! I've been looking forward to Merge Queues for a while.
>

Actually, rockstar did the modelling work and is the champion of this
stuff. My stuff merely piggy backs onto his :-)

> I have some comments below:
>
> * 1,500 lines? Why!? I'd suggest in future you look at splitting up work into two separate branches for plumbing and browser code, for example.

Yeah. It wasn't meant to be so big - the core code changes were quite
manageable. But by the time I finished writing all the unit tests, the
line count sky rocketed. Sorry.

> * import with_statement isn't needed any more, we're on Python 2.6!

Aaargh. That will teach me to cut'n'paste.

> * I'd suggest you run the import formatter over your branch.

I did that - utilities/format-imports is the right one to use? Not sure
what happened if there are still issues.

> * Why use Star Wars names in the tests, I'd prefer descriptive names, such as self.branch_owner, which is less distracting.

Ok. Others use names like eric which are equally non-descriptive :-) I
was trying to make writing tests a bit lest tedious :-)

> * You should use XXX, rather than TODO, and file a bug per the XXX Policy.

In this case, it's not so much a bug per say as something rockstar is
picking up and running with for the next iteration of work. So do these
collaborative development efforts still need a bug report for what is in
effect a handover of work?

> * getUtility can be imported from zope.component directly, and indeed you mostly are, except in one place.

Agggh. IDE auto import bites me again.

> * Investigate usage of IMasterStore, rather than getUtility(IStoreSelector), which is deprecated-ish

Will do. Thanks for the tip. I was basing my work on what I saw had been
done before.

> * You're adding BeautifulSoup and soupmatchers to setup.py and versions.cfg, I'd suggest that get split out into an earlier branch so you can be certain they are available before landing this one.

Hmmm. rockstar did this in his branch and mine is based on his. But
because he had trouble getting his through ec2, I merged from his
working copy to bootstrap my work. I didn't actually add those packages.
So perhaps there's a merge issue biting us?

[Ian Booth (wallyworld)]

Adding back comments from old incorrect merge proposal

lifeless wrote:

When you have a lower layer branch, use the 'dependent branch' feature
in LP's merge proposal facility.

[Ian Booth (wallyworld)]

I set the merge proposal's Prerequisite Branch to
lp:~rockstar/launchpad/merge-queues-model

This was the only option available when creating the merge proposal. Is
this what you mean by the 'dependent branch' facility? If so, I think I
did what I was supposed to do in this regard? Or not?

On 02/11/10 15:01, Robert Collins wrote:
> When you have a lower layer branch, use the 'dependent branch' feature
> in LP's merge proposal facility.
>
> _Rob

[Ian Booth (wallyworld)]

Hi Steve

I've done the requested fixes. However, I also looked again at the diff
as shown by the merge proposal and it seems there's a bit of a mix up
there. When I created the mp I included rockstar's branch as a
prerequisite to mine, but the diff contains some of his stuff eg
test_branchmergequeue. This is why the diff is so large. The other code
is also the culprit for the "import with_statement" stuff. So I would
love to find out what happened there.

On 02/11/10 13:22, Steve Kowalik wrote:
> Review: Needs Fixing code*
> Hi Ian,
>
> Firstly, thanks for this awesome work! I've been looking forward to Merge Queues for a while.
>
> I have some comments below:
>
> * 1,500 lines? Why!? I'd suggest in future you look at splitting up work into two separate branches for plumbing and browser code, for example.
> * import with_statement isn't needed any more, we're on Python 2.6!
> * I'd suggest you run the import formatter over your branch.
> * Why use Star Wars names in the tests, I'd prefer descriptive names, such as self.branch_owner, which is less distracting.
> * You should use XXX, rather than TODO, and file a bug per the XXX Policy.
> * getUtility can be imported from zope.component directly, and indeed you mostly are, except in one place.
> * Investigate usage of IMasterStore, rather than getUtility(IStoreSelector), which is deprecated-ish
> * You're adding BeautifulSoup and soupmatchers to setup.py and versions.cfg, I'd suggest that get split out into an earlier branch so you can be certain they are available before landing this one.

[Ian Booth (wallyworld)]

Ok. Got to the bottom of it. All the confusion in the above comments is because I chose the wrong pre-requisite branch. This mp fixes that. The diff should now be correct.

[Steve Kowalik (stevenk)]

Hi Ian,

You've lost some of the earlier changes for some reason -- the importing getUtility from the wrong place, and not using IMasterStore.

review: Needs Fixing (code*)

[Ian Booth (wallyworld)]

Hi Steve

I fixed it again locally and pushed the changes. The diff now reflects
the correct code.

Thanks.

On 03/11/10 16:49, Steve Kowalik wrote:
> Review: Needs Fixing code*
> Hi Ian,
>
> You've lost some of the earlier changes for some reason -- the importing getUtility from the wrong place, and not using IMasterStore.

[Steve Kowalik (stevenk)]

review: Approve (code*)

[Tim Penhey (thumper)]

Steve's review looks good.

review: Approve (mentor)

[Paul Hummer (rockstar)]

This looks fine, although a chat I had with jml has me questioning the usefulness of these pages in general. Maybe we can devise a nice javascript-y way of doing it in the future.

review: Approve (ui)

=== modified file 'lib/lp/code/browser/branchlisting.py'
--- lib/lp/code/browser/branchlisting.py	2010-10-29 14:36:59 +0000
+++ lib/lp/code/browser/branchlisting.py	2010-11-03 08:32:56 +0000
@@ -94,6 +94,7 @@
     PersonActiveReviewsView,
     PersonProductActiveReviewsView,
     )
+from lp.code.browser.branchmergequeuelisting import HasMergeQueuesMenuMixin
 from lp.code.browser.branchvisibilitypolicy import BranchVisibilityPolicyMixin
 from lp.code.browser.summary import BranchCountSummaryView
 from lp.code.enums import (
@@ -849,18 +850,19 @@
                 .scanned())
 
 
-class PersonBranchesMenu(ApplicationMenu):
+class PersonBranchesMenu(ApplicationMenu, HasMergeQueuesMenuMixin):
 
     usedfor = IPerson
     facet = 'branches'
     links = ['registered', 'owned', 'subscribed', 'addbranch',
-             'active_reviews']
+             'active_reviews', 'mergequeues']
     extra_attributes = [
         'active_review_count',
         'owned_branch_count',
         'registered_branch_count',
         'show_summary',
         'subscribed_branch_count',
+        'mergequeue_count',
         ]
 
     def _getCountCollection(self):

=== added file 'lib/lp/code/browser/branchmergequeuelisting.py'
--- lib/lp/code/browser/branchmergequeuelisting.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/browser/branchmergequeuelisting.py	2010-11-03 08:32:56 +0000
@@ -0,0 +1,105 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Base class view for merge queue listings."""
+
+__metaclass__ = type
+
+__all__ = [
+    'MergeQueueListingView',
+    'HasMergeQueuesMenuMixin',
+    'PersonMergeQueueListingView',
+    ]
+
+from zope.component import getUtility
+
+from canonical.launchpad.browser.feeds import FeedsMixin
+from canonical.launchpad.webapp import (
+    LaunchpadView,
+    Link,
+    )
+from lp.code.interfaces.branchmergequeuecollection import (
+    IAllBranchMergeQueues,
+    )
+from lp.services.browser_helpers import get_plural_text
+from lp.services.propertycache import cachedproperty
+
+
+class HasMergeQueuesMenuMixin:
+    """A context menus mixin for objects that can own merge queues."""
+
+    def _getCollection(self):
+        return getUtility(IAllBranchMergeQueues).visibleByUser(self.user)
+
+    @property
+    def person(self):
+        """The `IPerson` for the context of the view.
+
+        In simple cases this is the context itself, but in others, like the
+        PersonProduct, it is an attribute of the context.
+        """
+        return self.context
+
+    def mergequeues(self):
+        return Link(
+            '+merge-queues',
+            get_plural_text(
+                self.mergequeue_count,
+                'merge queue', 'merge queues'), site='code')
+
+    @cachedproperty
+    def mergequeue_count(self):
+        return self._getCollection().ownedBy(self.person).count()
+
+
+class MergeQueueListingView(LaunchpadView, FeedsMixin):
+
+    # No feeds initially
+    feed_types = ()
+
+    branch_enabled = True
+    owner_enabled = True
+
+    label_template = 'Merge Queues for %(displayname)s'
+
+    @property
+    def label(self):
+        return self.label_template % {
+            'displayname': self.context.displayname,
+            'title': getattr(self.context, 'title', 'no-title')}
+
+    # Provide a default page_title for distros and other things without
+    # breadcrumbs..
+    page_title = label
+
+    def _getCollection(self):
+        """Override this to say what queues will be in the listing."""
+        raise NotImplementedError(self._getCollection)
+
+    def getVisibleQueuesForUser(self):
+        """Branch merge queues that are visible by the logged in user."""
+        collection = self._getCollection().visibleByUser(self.user)
+        return collection.getMergeQueues()
+
+    @cachedproperty
+    def mergequeues(self):
+        return self.getVisibleQueuesForUser()
+
+    @cachedproperty
+    def mergequeue_count(self):
+        """Return the number of merge queues that will be returned."""
+        return self._getCollection().visibleByUser(self.user).count()
+
+    @property
+    def no_merge_queue_message(self):
+        """Shown when there is no table to show."""
+        return "%s has no merge queues." % self.context.displayname
+
+
+class PersonMergeQueueListingView(MergeQueueListingView):
+
+    label_template = 'Merge Queues owned by %(displayname)s'
+    owner_enabled = False
+
+    def _getCollection(self):
+        return getUtility(IAllBranchMergeQueues).ownedBy(self.context)

=== modified file 'lib/lp/code/browser/configure.zcml'
--- lib/lp/code/browser/configure.zcml	2010-11-03 08:32:55 +0000
+++ lib/lp/code/browser/configure.zcml	2010-11-03 08:32:56 +0000
@@ -1318,6 +1318,24 @@
             for="lp.code.interfaces.sourcepackagerecipe.ISourcePackageRecipe"
             factory="canonical.launchpad.webapp.breadcrumb.NameBreadcrumb"
             permission="zope.Public"/>
+
+        <browser:page
+            for="lp.registry.interfaces.person.IPerson"
+            layer="lp.code.publisher.CodeLayer"
+            class="lp.code.browser.branchmergequeuelisting.PersonMergeQueueListingView"
+            permission="zope.Public"
+            facet="branches"
+            name="+merge-queues"
+            template="../templates/branchmergequeue-listing.pt"/>
+
+        <browser:page
+            for="*"
+            layer="lp.code.publisher.CodeLayer"
+            name="+bmq-macros"
+            permission="zope.Public"
+            template="../templates/branchmergequeue-macros.pt"/>
+
+
     </facet>
 
     <browser:url

=== added file 'lib/lp/code/browser/tests/test_branchmergequeuelisting.py'
--- lib/lp/code/browser/tests/test_branchmergequeuelisting.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/browser/tests/test_branchmergequeuelisting.py	2010-11-03 08:32:56 +0000
@@ -0,0 +1,227 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for branch listing."""
+
+__metaclass__ = type
+
+import re
+
+from mechanize import LinkNotFoundError
+import soupmatchers
+from zope.security.proxy import removeSecurityProxy
+
+from canonical.launchpad.testing.pages import (
+    extract_link_from_tag,
+    extract_text,
+    find_tag_by_id,
+    )
+from canonical.launchpad.webapp import canonical_url
+from canonical.testing.layers import DatabaseFunctionalLayer
+from lp.services.features.model import (
+    FeatureFlag,
+    getFeatureStore,
+    )
+from lp.testing import (
+    BrowserTestCase,
+    login_person,
+    person_logged_in,
+    TestCaseWithFactory,
+    )
+from lp.testing.views import create_initialized_view
+
+
+class MergeQueuesTestMixin:
+
+    def setUp(self):
+        self.branch_owner = self.factory.makePerson(name='eric')
+
+    def enable_queue_flag(self):
+        getFeatureStore().add(FeatureFlag(
+            scope=u'default', flag=u'code.branchmergequeue',
+            value=u'on', priority=1))
+
+    def _makeMergeQueues(self, nr_queues=3, nr_with_private_branches=0):
+        # We create nr_queues merge queues in total, and the first
+        # nr_with_private_branches of them will have at least one private
+        # branch in the queue.
+        with person_logged_in(self.branch_owner):
+            mergequeues = [
+                self.factory.makeBranchMergeQueue(
+                    owner=self.branch_owner, branches=self._makeBranches())
+                for i in range(nr_queues-nr_with_private_branches)]
+            mergequeues_with_private_branches = [
+                self.factory.makeBranchMergeQueue(
+                    owner=self.branch_owner,
+                    branches=self._makeBranches(nr_private=1))
+                for i in range(nr_with_private_branches)]
+
+            return mergequeues, mergequeues_with_private_branches
+
+    def _makeBranches(self, nr_public=3, nr_private=0):
+        branches = [
+            self.factory.makeProductBranch(owner=self.branch_owner)
+            for i in range(nr_public)]
+
+        private_branches = [
+            self.factory.makeProductBranch(
+                owner=self.branch_owner, private=True)
+            for i in range(nr_private)]
+
+        branches.extend(private_branches)
+        return branches
+
+
+class TestPersonMergeQueuesView(TestCaseWithFactory, MergeQueuesTestMixin):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        MergeQueuesTestMixin.setUp(self)
+        self.user = self.factory.makePerson()
+
+    def test_mergequeues_with_all_public_branches(self):
+        # Anyone can see mergequeues containing all public branches.
+        mq, mq_with_private = self._makeMergeQueues()
+        login_person(self.user)
+        view = create_initialized_view(
+            self.branch_owner, name="+merge-queues", rootsite='code')
+        self.assertEqual(set(mq), set(view.mergequeues))
+
+    def test_mergequeues_with_a_private_branch_for_owner(self):
+        # Only users with access to private branches can see any queues
+        # containing such branches.
+        mq, mq_with_private = (
+            self._makeMergeQueues(nr_with_private_branches=1))
+        login_person(self.branch_owner)
+        view = create_initialized_view(
+            self.branch_owner, name="+merge-queues", rootsite='code')
+        mq.extend(mq_with_private)
+        self.assertEqual(set(mq), set(view.mergequeues))
+
+    def test_mergequeues_with_a_private_branch_for_other_user(self):
+        # Only users with access to private branches can see any queues
+        # containing such branches.
+        mq, mq_with_private = (
+            self._makeMergeQueues(nr_with_private_branches=1))
+        login_person(self.user)
+        view = create_initialized_view(
+            self.branch_owner, name="+merge-queues", rootsite='code')
+        self.assertEqual(set(mq), set(view.mergequeues))
+
+
+class TestPersonCodePage(BrowserTestCase, MergeQueuesTestMixin):
+    """Tests for the person code homepage.
+
+    This is the default page shown for a person on the code subdomain.
+    """
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        BrowserTestCase.setUp(self)
+        MergeQueuesTestMixin.setUp(self)
+        self._makeMergeQueues()
+
+    def test_merge_queue_menu_link_without_feature_flag(self):
+        login_person(self.branch_owner)
+        browser = self.getUserBrowser(
+            canonical_url(self.branch_owner, rootsite='code'),
+            self.branch_owner)
+        self.assertRaises(
+            LinkNotFoundError,
+            browser.getLink,
+            url='+merge-queues')
+
+    def test_merge_queue_menu_link(self):
+        self.enable_queue_flag()
+        login_person(self.branch_owner)
+        browser = self.getUserBrowser(
+            canonical_url(self.branch_owner, rootsite='code'),
+            self.branch_owner)
+        browser.getLink(url='+merge-queues').click()
+        self.assertEqual(
+            'http://code.launchpad.dev/~eric/+merge-queues',
+            browser.url)
+
+
+class TestPersonMergeQueuesListPage(BrowserTestCase, MergeQueuesTestMixin):
+    """Tests for the person merge queue list page."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        BrowserTestCase.setUp(self)
+        MergeQueuesTestMixin.setUp(self)
+        mq, mq_with_private = self._makeMergeQueues()
+        self.merge_queues = mq
+        self.merge_queues.extend(mq_with_private)
+
+    def test_merge_queue_list_contents_without_feature_flag(self):
+        login_person(self.branch_owner)
+        browser = self.getUserBrowser(
+            canonical_url(self.branch_owner, rootsite='code',
+                          view_name='+merge-queues'), self.branch_owner)
+        table = find_tag_by_id(browser.contents, 'mergequeuetable')
+        self.assertIs(None, table)
+        noqueue_matcher = soupmatchers.HTMLContains(
+            soupmatchers.Tag(
+                'No merge queues', 'div',
+                text=re.compile(
+                    '\w*No merge queues\w*')))
+        self.assertThat(browser.contents, noqueue_matcher)
+
+    def test_merge_queue_list_contents(self):
+        self.enable_queue_flag()
+        login_person(self.branch_owner)
+        browser = self.getUserBrowser(
+            canonical_url(self.branch_owner, rootsite='code',
+                          view_name='+merge-queues'), self.branch_owner)
+
+        table = find_tag_by_id(browser.contents, 'mergequeuetable')
+
+        merge_queue_info = {}
+        for row in table.tbody.fetch('tr'):
+            cells = row('td')
+            row_info = {}
+            queue_name = extract_text(cells[0])
+            if not queue_name.startswith('queue'):
+                continue
+            qlink = extract_link_from_tag(cells[0].find('a'))
+            row_info['queue_link'] = qlink
+            queue_size = extract_text(cells[1])
+            row_info['queue_size'] = queue_size
+            queue_branches = cells[2]('a')
+            branch_links = set()
+            for branch_tag in queue_branches:
+                branch_links.add(extract_link_from_tag(branch_tag))
+            row_info['branch_links'] = branch_links
+            merge_queue_info[queue_name] = row_info
+
+        expected_queue_names = [queue.name for queue in self.merge_queues]
+        self.assertEqual(
+            set(expected_queue_names), set(merge_queue_info.keys()))
+
+        #TODO: when IBranchMergeQueue API is available remove '4'
+        expected_queue_sizes = dict(
+            [(queue.name, '4') for queue in self.merge_queues])
+        observed_queue_sizes = dict(
+            [(queue.name, merge_queue_info[queue.name]['queue_size'])
+             for queue in self.merge_queues])
+        self.assertEqual(
+            expected_queue_sizes, observed_queue_sizes)
+
+        def branch_links(branches):
+            return [canonical_url(removeSecurityProxy(branch),
+                                  force_local_path=True)
+                    for branch in branches]
+
+        expected_queue_branches = dict(
+            [(queue.name, set(branch_links(queue.branches)))
+             for queue in self.merge_queues])
+        observed_queue_branches = dict(
+            [(queue.name, merge_queue_info[queue.name]['branch_links'])
+             for queue in self.merge_queues])
+        self.assertEqual(
+            expected_queue_branches, observed_queue_branches)

=== modified file 'lib/lp/code/configure.zcml'
--- lib/lp/code/configure.zcml	2010-10-26 13:52:43 +0000
+++ lib/lp/code/configure.zcml	2010-11-03 08:32:56 +0000
@@ -94,6 +94,12 @@
     <allow attributes="browserDefault
                        __call__"/>
   </class>
+  <class class="lp.code.model.branchmergequeuecollection.GenericBranchMergeQueueCollection">
+    <allow interface="lp.code.interfaces.branchmergequeuecollection.IBranchMergeQueueCollection"/>
+  </class>
+  <class class="lp.code.model.branchmergequeuecollection.VisibleBranchMergeQueueCollection">
+    <allow interface="lp.code.interfaces.branchmergequeuecollection.IBranchMergeQueueCollection"/>
+  </class>
   <class class="lp.code.model.branchcollection.GenericBranchCollection">
     <allow interface="lp.code.interfaces.branchcollection.IBranchCollection"/>
   </class>
@@ -148,6 +154,11 @@
       provides="lp.code.interfaces.revisioncache.IRevisionCache">
     <allow interface="lp.code.interfaces.revisioncache.IRevisionCache"/>
   </securedutility>
+  <securedutility
+      class="lp.code.model.branchmergequeuecollection.GenericBranchMergeQueueCollection"
+      provides="lp.code.interfaces.branchmergequeuecollection.IAllBranchMergeQueues">
+    <allow interface="lp.code.interfaces.branchmergequeuecollection.IAllBranchMergeQueues"/>
+  </securedutility>
   <adapter
       for="lp.registry.interfaces.person.IPerson"
       provides="lp.code.interfaces.revisioncache.IRevisionCache"

=== modified file 'lib/lp/code/interfaces/branchmergequeue.py'
--- lib/lp/code/interfaces/branchmergequeue.py	2010-10-20 15:32:38 +0000
+++ lib/lp/code/interfaces/branchmergequeue.py	2010-11-03 08:32:56 +0000
@@ -8,6 +8,7 @@
 __all__ = [
     'IBranchMergeQueue',
     'IBranchMergeQueueSource',
+    'user_has_special_merge_queue_access',
     ]
 
 from lazr.restful.declarations import (
@@ -21,6 +22,7 @@
     CollectionField,
     Reference,
     )
+from zope.component import getUtility
 from zope.interface import Interface
 from zope.schema import (
     Datetime,
@@ -30,6 +32,7 @@
     )
 
 from canonical.launchpad import _
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
 from lp.services.fields import (
     PersonChoice,
     PublicPersonChoice,
@@ -113,3 +116,14 @@
         :param registrant: The registrant of the queue.
         :param branches: A list of branches to add to the queue.
         """
+
+
+def user_has_special_merge_queue_access(user):
+    """Admins and bazaar experts have special access.
+
+    :param user: A 'Person' or None.
+    """
+    if user is None:
+        return False
+    celebs = getUtility(ILaunchpadCelebrities)
+    return user.inTeam(celebs.admin) or user.inTeam(celebs.bazaar_experts)

=== added file 'lib/lp/code/interfaces/branchmergequeuecollection.py'
--- lib/lp/code/interfaces/branchmergequeuecollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/interfaces/branchmergequeuecollection.py	2010-11-03 08:32:56 +0000
@@ -0,0 +1,64 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+# pylint: disable-msg=E0211, E0213
+
+"""A collection of branche merge queues.
+
+See `IBranchMergeQueueCollection` for more details.
+"""
+
+__metaclass__ = type
+__all__ = [
+    'IAllBranchMergeQueues',
+    'IBranchMergeQueueCollection',
+    'InvalidFilter',
+    ]
+
+from zope.interface import Interface
+
+
+class InvalidFilter(Exception):
+    """Raised when an `IBranchMergeQueueCollection` can't apply the filter."""
+
+
+class IBranchMergeQueueCollection(Interface):
+    """A collection of branch merge queues.
+
+    An `IBranchMergeQueueCollection` is an immutable collection of branch
+    merge queues. It has two kinds of methods:
+    filter methods and query methods.
+
+    Query methods get information about the contents of collection. See
+    `IBranchMergeQueueCollection.count` and
+    `IBranchMergeQueueCollection.getMergeQueues`.
+
+    Implementations of this interface are not 'content classes'. That is, they
+    do not correspond to a particular row in the database.
+
+    This interface is intended for use within Launchpad, not to be exported as
+    a public API.
+    """
+
+    def count():
+        """The number of merge queues in this collection."""
+
+    def getMergeQueues():
+        """Return a result set of all merge queues in this collection.
+
+        The returned result set will also join across the specified tables as
+        defined by the arguments to this function.  These extra tables are
+        joined specificly to allow the caller to sort on values not in the
+        Branch table itself.
+        """
+
+    def ownedBy(person):
+        """Restrict the collection to queues owned by 'person'."""
+
+    def visibleByUser(person):
+        """Restrict the collection to queues that 'person' is allowed to see.
+        """
+
+
+class IAllBranchMergeQueues(IBranchMergeQueueCollection):
+    """An `IBranchMergeQueueCollection` of all branch merge queues."""

=== modified file 'lib/lp/code/model/branchmergequeue.py'
--- lib/lp/code/model/branchmergequeue.py	2010-11-03 08:32:55 +0000
+++ lib/lp/code/model/branchmergequeue.py	2010-11-03 08:32:56 +0000
@@ -7,7 +7,6 @@
 __all__ = ['BranchMergeQueue']
 
 import simplejson
-
 from storm.locals import (
     Int,
     Reference,
@@ -68,7 +67,7 @@
 
     @classmethod
     def new(cls, name, owner, registrant, description=None,
-            configuration=None):
+            configuration=None, branches=None):
         """See `IBranchMergeQueueSource`."""
         store = IMasterStore(BranchMergeQueue)
 
@@ -81,6 +80,9 @@
         queue.registrant = registrant
         queue.description = description
         queue.configuration = configuration
+        if branches is not None:
+            for branch in branches:
+                branch.addToQueue(queue)
 
         store.add(queue)
         return queue

=== added file 'lib/lp/code/model/branchmergequeuecollection.py'
--- lib/lp/code/model/branchmergequeuecollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/model/branchmergequeuecollection.py	2010-11-03 08:32:56 +0000
@@ -0,0 +1,174 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Implementations of `IBranchMergeQueueCollection`."""
+
+__metaclass__ = type
+__all__ = [
+    'GenericBranchCollection',
+    ]
+
+from zope.interface import implements
+
+from canonical.launchpad.interfaces.lpstorm import IMasterStore
+from lp.code.interfaces.branchmergequeue import (
+    user_has_special_merge_queue_access,
+    )
+from lp.code.interfaces.branchmergequeuecollection import (
+    IBranchMergeQueueCollection,
+    InvalidFilter,
+    )
+from lp.code.interfaces.codehosting import LAUNCHPAD_SERVICES
+from lp.code.model.branchmergequeue import BranchMergeQueue
+
+
+class GenericBranchMergeQueueCollection:
+    """See `IBranchMergeQueueCollection`."""
+
+    implements(IBranchMergeQueueCollection)
+
+    def __init__(self, store=None, merge_queue_filter_expressions=None,
+                 tables=None, exclude_from_search=None):
+        """Construct a `GenericBranchMergeQueueCollection`.
+
+        :param store: The store to look in for merge queues. If not specified,
+            use the default store.
+        :param merge_queue_filter_expressions: A list of Storm expressions to
+            restrict the queues in the collection. If unspecified, then
+            there will be no restrictions on the result set. That is, all
+            queues in the store will be in the collection.
+        :param tables: A dict of Storm tables to the Join expression.  If an
+            expression in merge_queue_filter_expressions refers to a table,
+            then that table *must* be in this list.
+        """
+        self._store = store
+        if merge_queue_filter_expressions is None:
+            merge_queue_filter_expressions = []
+        self._merge_queue_filter_expressions = merge_queue_filter_expressions
+        if tables is None:
+            tables = {}
+        self._tables = tables
+        if exclude_from_search is None:
+            exclude_from_search = []
+        self._exclude_from_search = exclude_from_search
+
+    def count(self):
+        return self._getCount()
+
+    def _getCount(self):
+        """See `IBranchMergeQueueCollection`."""
+        return self._getMergeQueues().count()
+
+    @property
+    def store(self):
+        if self._store is None:
+            return IMasterStore(BranchMergeQueue)
+        else:
+            return self._store
+
+    def _filterBy(self, expressions, table=None, join=None,
+                  exclude_from_search=None):
+        """Return a subset of this collection, filtered by 'expressions'."""
+        tables = self._tables.copy()
+        if table is not None:
+            if join is None:
+                raise InvalidFilter("Cannot specify a table without a join.")
+            tables[table] = join
+        if exclude_from_search is None:
+            exclude_from_search = []
+        if expressions is None:
+            expressions = []
+        return self.__class__(
+            self.store,
+            self._merge_queue_filter_expressions + expressions,
+            tables,
+            self._exclude_from_search + exclude_from_search)
+
+    def _getMergeQueueExpressions(self):
+        """Return the where expressions for this collection."""
+        return self._merge_queue_filter_expressions
+
+    def getMergeQueues(self):
+        return list(self._getMergeQueues())
+
+    def _getMergeQueues(self):
+        """See `IBranchMergeQueueCollection`."""
+        tables = [BranchMergeQueue] + self._tables.values()
+        expressions = self._getMergeQueueExpressions()
+        return self.store.using(*tables).find(BranchMergeQueue, *expressions)
+
+    def ownedBy(self, person):
+        """See `IBranchMergeQueueCollection`."""
+        return self._filterBy([BranchMergeQueue.owner == person])
+
+    def visibleByUser(self, person):
+        """See `IBranchMergeQueueCollection`."""
+        if (person == LAUNCHPAD_SERVICES or
+            user_has_special_merge_queue_access(person)):
+            return self
+        return VisibleBranchMergeQueueCollection(
+            person,
+            self._store, None,
+            self._tables, self._exclude_from_search)
+
+
+class VisibleBranchMergeQueueCollection(GenericBranchMergeQueueCollection):
+    """A mergequeue collection which provides queues visible by a user."""
+
+    def __init__(self, person, store=None,
+                 merge_queue_filter_expressions=None, tables=None,
+                 exclude_from_search=None):
+        super(VisibleBranchMergeQueueCollection, self).__init__(
+            store=store,
+            merge_queue_filter_expressions=merge_queue_filter_expressions,
+            tables=tables,
+            exclude_from_search=exclude_from_search,
+        )
+        self._user = person
+
+    def _filterBy(self, expressions, table=None, join=None,
+                  exclude_from_search=None):
+        """Return a subset of this collection, filtered by 'expressions'."""
+        tables = self._tables.copy()
+        if table is not None:
+            if join is None:
+                raise InvalidFilter("Cannot specify a table without a join.")
+            tables[table] = join
+        if exclude_from_search is None:
+            exclude_from_search = []
+        if expressions is None:
+            expressions = []
+        return self.__class__(
+            self._user,
+            self.store,
+            self._merge_queue_filter_expressions + expressions,
+            tables,
+            self._exclude_from_search + exclude_from_search)
+
+    def visibleByUser(self, person):
+        """See `IBranchMergeQueueCollection`."""
+        if person == self._user:
+            return self
+        raise InvalidFilter(
+            "Cannot filter for merge queues visible by user %r, already "
+            "filtering for %r" % (person, self._user))
+
+    def _getCount(self):
+        """See `IBranchMergeQueueCollection`."""
+        return len(self._getMergeQueues())
+
+    def _getMergeQueues(self):
+        """Return the queues visible by self._user.
+
+        A queue is visible to a user if that user can see all the branches
+        associated with the queue.
+        """
+
+        def allBranchesVisible(user, branches):
+            return len([branch for branch in branches
+                        if branch.visibleByUser(user)]) == branches.count()
+
+        queues = super(
+            VisibleBranchMergeQueueCollection, self)._getMergeQueues()
+        return [queue for queue in queues
+                if allBranchesVisible(self._user, queue.branches)]

=== added file 'lib/lp/code/model/tests/test_branchmergequeuecollection.py'
--- lib/lp/code/model/tests/test_branchmergequeuecollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/model/tests/test_branchmergequeuecollection.py	2010-11-03 08:32:56 +0000
@@ -0,0 +1,201 @@
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for branch merge queue collections."""
+
+__metaclass__ = type
+
+from zope.component import getUtility
+from zope.security.proxy import removeSecurityProxy
+
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from canonical.launchpad.interfaces.lpstorm import IMasterStore
+from canonical.testing.layers import DatabaseFunctionalLayer
+from lp.code.interfaces.branchmergequeuecollection import (
+    IAllBranchMergeQueues,
+    IBranchMergeQueueCollection,
+    )
+from lp.code.interfaces.codehosting import LAUNCHPAD_SERVICES
+from lp.code.model.branchmergequeue import BranchMergeQueue
+from lp.code.model.branchmergequeuecollection import (
+    GenericBranchMergeQueueCollection,
+    )
+from lp.testing import TestCaseWithFactory
+
+
+class TestGenericBranchMergeQueueCollection(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.store = IMasterStore(BranchMergeQueue)
+
+    def test_provides_branchmergequeuecollection(self):
+        # `GenericBranchMergeQueueCollection`
+        # provides the `IBranchMergeQueueCollection` interface.
+        self.assertProvides(
+            GenericBranchMergeQueueCollection(self.store),
+            IBranchMergeQueueCollection)
+
+    def test_getMergeQueues_no_filter_no_queues(self):
+        # If no filter is specified, then the collection is of all branches
+        # merge queues. By default, there are no branch merge queues.
+        collection = GenericBranchMergeQueueCollection(self.store)
+        self.assertEqual([], list(collection.getMergeQueues()))
+
+    def test_getMergeQueues_no_filter(self):
+        # If no filter is specified, then the collection is of all branch
+        # merge queues.
+        collection = GenericBranchMergeQueueCollection(self.store)
+        queue = self.factory.makeBranchMergeQueue()
+        self.assertEqual([queue], list(collection.getMergeQueues()))
+
+    def test_count(self):
+        # The 'count' property of a collection is the number of elements in
+        # the collection.
+        collection = GenericBranchMergeQueueCollection(self.store)
+        self.assertEqual(0, collection.count())
+        for i in range(3):
+            self.factory.makeBranchMergeQueue()
+        self.assertEqual(3, collection.count())
+
+    def test_count_respects_filter(self):
+        # If a collection is a subset of all possible queues, then the count
+        # will be the size of that subset. That is, 'count' respects any
+        # filters that are applied.
+        person = self.factory.makePerson()
+        queue = self.factory.makeBranchMergeQueue(owner=person)
+        queue2 = self.factory.makeAnyBranch()
+        collection = GenericBranchMergeQueueCollection(
+            self.store, [BranchMergeQueue.owner == person])
+        self.assertEqual(1, collection.count())
+
+
+class TestBranchMergeQueueCollectionFilters(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.all_queues = getUtility(IAllBranchMergeQueues)
+
+    def test_count_respects_visibleByUser_filter(self):
+        # IBranchMergeQueueCollection.count() returns the number of queues
+        # that getMergeQueues() yields, even when the visibleByUser filter is
+        # applied.
+        branch = self.factory.makeAnyBranch(private=True)
+        naked_branch = removeSecurityProxy(branch)
+        queue = self.factory.makeBranchMergeQueue(branches=[naked_branch])
+        branch2 = self.factory.makeAnyBranch(private=True)
+        naked_branch2 = removeSecurityProxy(branch2)
+        queue2 = self.factory.makeBranchMergeQueue(branches=[naked_branch2])
+        collection = self.all_queues.visibleByUser(naked_branch.owner)
+        self.assertEqual(1, len(collection.getMergeQueues()))
+        self.assertEqual(1, collection.count())
+
+    def test_ownedBy(self):
+        # 'ownedBy' returns a new collection restricted to queues owned by
+        # the given person.
+        queue = self.factory.makeBranchMergeQueue()
+        queue2 = self.factory.makeBranchMergeQueue()
+        collection = self.all_queues.ownedBy(queue.owner)
+        self.assertEqual([queue], collection.getMergeQueues())
+
+
+class TestGenericBranchMergeQueueCollectionVisibleFilter(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        public_branch = self.factory.makeAnyBranch(name='public')
+        self.queue_with_public_branch = self.factory.makeBranchMergeQueue(
+            branches=[removeSecurityProxy(public_branch)])
+        private_branch1 = self.factory.makeAnyBranch(
+            private=True, name='private1')
+        naked_private_branch1 = removeSecurityProxy(private_branch1)
+        self.private_branch1_owner = naked_private_branch1.owner
+        self.queue1_with_private_branch = self.factory.makeBranchMergeQueue(
+            branches=[naked_private_branch1])
+        private_branch2 = self.factory.makeAnyBranch(
+            private=True, name='private2')
+        self.queue2_with_private_branch = self.factory.makeBranchMergeQueue(
+            branches=[removeSecurityProxy(private_branch2)])
+        self.all_queues = getUtility(IAllBranchMergeQueues)
+
+    def test_all_queues(self):
+        # Without the visibleByUser filter, all queues are in the
+        # collection.
+        self.assertEqual(
+            sorted([self.queue_with_public_branch,
+                    self.queue1_with_private_branch,
+                    self.queue2_with_private_branch]),
+            sorted(self.all_queues.getMergeQueues()))
+
+    def test_anonymous_sees_only_public(self):
+        # Anonymous users can see only queues with public branches.
+        queues = self.all_queues.visibleByUser(None)
+        self.assertEqual([self.queue_with_public_branch],
+                         list(queues.getMergeQueues()))
+
+    def test_random_person_sees_only_public(self):
+        # Logged in users with no special permissions can see only queues with
+        # public branches.
+        person = self.factory.makePerson()
+        queues = self.all_queues.visibleByUser(person)
+        self.assertEqual([self.queue_with_public_branch],
+                         list(queues.getMergeQueues()))
+
+    def test_owner_sees_own_branches(self):
+        # Users can always see the queues with branches that they own, as well
+        # as queues with public branches.
+        queues = self.all_queues.visibleByUser(self.private_branch1_owner)
+        self.assertEqual(
+            sorted([self.queue_with_public_branch,
+                    self.queue1_with_private_branch]),
+            sorted(queues.getMergeQueues()))
+
+    def test_owner_member_sees_own_queues(self):
+        # Members of teams that own queues can see queues owned by those
+        # teams, as well as public branches.
+        team_owner = self.factory.makePerson()
+        team = self.factory.makeTeam(team_owner)
+        private_branch = self.factory.makeAnyBranch(
+            owner=team, private=True, name='team')
+        queue_with_private_branch = self.factory.makeBranchMergeQueue(
+            branches=[removeSecurityProxy(private_branch)])
+        queues = self.all_queues.visibleByUser(team_owner)
+        self.assertEqual(
+            sorted([self.queue_with_public_branch,
+                    queue_with_private_branch]),
+            sorted(queues.getMergeQueues()))
+
+    def test_launchpad_services_sees_all(self):
+        # The LAUNCHPAD_SERVICES special user sees *everything*.
+        queues = self.all_queues.visibleByUser(LAUNCHPAD_SERVICES)
+        self.assertEqual(
+            sorted(self.all_queues.getMergeQueues()),
+            sorted(queues.getMergeQueues()))
+
+    def test_admins_see_all(self):
+        # Launchpad administrators see *everything*.
+        admin = self.factory.makePerson()
+        admin_team = removeSecurityProxy(
+            getUtility(ILaunchpadCelebrities).admin)
+        admin_team.addMember(admin, admin_team.teamowner)
+        queues = self.all_queues.visibleByUser(admin)
+        self.assertEqual(
+            sorted(self.all_queues.getMergeQueues()),
+            sorted(queues.getMergeQueues()))
+
+    def test_bazaar_experts_see_all(self):
+        # Members of the bazaar_experts team see *everything*.
+        bzr_experts = removeSecurityProxy(
+            getUtility(ILaunchpadCelebrities).bazaar_experts)
+        expert = self.factory.makePerson()
+        bzr_experts.addMember(expert, bzr_experts.teamowner)
+        queues = self.all_queues.visibleByUser(expert)
+        self.assertEqual(
+            sorted(self.all_queues.getMergeQueues()),
+            sorted(queues.getMergeQueues()))

=== added file 'lib/lp/code/templates/branchmergequeue-listing.pt'
--- lib/lp/code/templates/branchmergequeue-listing.pt	1970-01-01 00:00:00 +0000
+++ lib/lp/code/templates/branchmergequeue-listing.pt	2010-11-03 08:32:56 +0000
@@ -0,0 +1,68 @@
+<html
+  xmlns="http://www.w3.org/1999/xhtml"
+  xmlns:tal="http://xml.zope.org/namespaces/tal"
+  xmlns:metal="http://xml.zope.org/namespaces/metal"
+  xmlns:i18n="http://xml.zope.org/namespaces/i18n"
+  metal:use-macro="view/macro:page/main_only"
+  i18n:domain="launchpad">
+
+<body>
+
+  <div metal:fill-slot="main">
+
+    <div tal:condition="not: features/code.branchmergequeue">
+        <em>
+         No merge queues
+        </em>
+    </div>
+
+    <div tal:condition="features/code.branchmergequeue">
+
+        <tal:has-queues condition="view/mergequeue_count">
+
+            <table id="mergequeuetable" class="listing sortable">
+              <thead>
+                <tr>
+                  <th colspan="2">Name</th>
+                  <th tal:condition="view/owner_enabled">Owner</th>
+                  <th>Queue Size</th>
+                  <th>Associated Branches</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tal:mergequeues repeat="mergeQueue view/mergequeues">
+                  <tr>
+                    <td colspan="2">
+                      <a tal:attributes="href mergeQueue/fmt:url"
+                         tal:content="mergeQueue/name">Merge queue name</a>
+                    </td>
+                    <td tal:condition="view/owner_enabled">
+                      <a tal:replace="structure mergeQueue/owner/fmt:link">
+                        Owner
+                      </a>
+                    </td>
+                    <td>4</td>
+                    <td>
+                        <metal:display-branches
+                            use-macro="context/@@+bmq-macros/merge_queue_branches"/>
+                    </td>
+                  </tr>
+                </tal:mergequeues>
+              </tbody>
+            </table>
+
+        </tal:has-queues>
+
+        <em id="no-queues"
+         tal:condition="not: view/mergequeue_count"
+         tal:content="view/no_merge_queue_message">
+         No merge queues
+        </em>
+
+    </div>
+
+  </div>
+
+</body>
+</html>
+

=== added file 'lib/lp/code/templates/branchmergequeue-macros.pt'
--- lib/lp/code/templates/branchmergequeue-macros.pt	1970-01-01 00:00:00 +0000
+++ lib/lp/code/templates/branchmergequeue-macros.pt	2010-11-03 08:32:56 +0000
@@ -0,0 +1,20 @@
+ <tal:root
+   xmlns:tal="http://xml.zope.org/namespaces/tal"
+   xmlns:metal="http://xml.zope.org/namespaces/metal"
+   omit-tag="">
+
+<metal:merge_queue_branches define-macro="merge_queue_branches">
+    <table class="listing">
+          <tbody>
+            <tal:mergequeue-branches repeat="branch mergeQueue/branches">
+              <tr>
+                <td>
+                  <a tal:attributes="href branch/fmt:url"
+                     tal:content="branch/name">Branch name</a>
+                </td>
+              </tr>
+            </tal:mergequeue-branches>
+          </tbody>
+    </table>
+</metal:merge_queue_branches>
+</tal:root>
\ No newline at end of file

=== modified file 'lib/lp/code/templates/person-codesummary.pt'
--- lib/lp/code/templates/person-codesummary.pt	2010-10-15 01:48:05 +0000
+++ lib/lp/code/templates/person-codesummary.pt	2010-11-03 08:32:56 +0000
@@ -4,7 +4,8 @@
   xmlns:i18n="http://xml.zope.org/namespaces/i18n"
   id="portlet-person-codesummary"
   class="portlet"
-  tal:define="menu context/menu:branches"
+  tal:define="menu context/menu:branches;
+      features request/features"
   tal:condition="menu/show_summary">
 
   <table>
@@ -32,5 +33,11 @@
           tal:content="structure menu/active_reviews/render"
           />
     </tr>
+    <tr tal:condition="features/code.branchmergequeue" id="mergequeue-counts">
+      <td class="code-count" tal:content="menu/mergequeue_count">5</td>
+      <td tal:condition="menu"
+          tal:content="structure menu/mergequeues/render"
+          />
+    </tr>
   </table>
 </div>

=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2010-11-03 08:32:55 +0000
+++ lib/lp/testing/factory.py	2010-11-03 08:32:56 +0000
@@ -37,7 +37,6 @@
     )
 import os
 from random import randint
-import simplejson
 from StringIO import StringIO
 from textwrap import dedent
 from threading import local
@@ -47,6 +46,7 @@
 from bzrlib.merge_directive import MergeDirective2
 from bzrlib.plugins.builder.recipe import BaseRecipeBranch
 import pytz
+import simplejson
 from twisted.python.util import mergeFunctionMetadata
 from zope.component import (
     ComponentLookupError,
@@ -1113,7 +1113,8 @@
         return namespace.createBranch(branch_type, name, creator)
 
     def makeBranchMergeQueue(self, registrant=None, owner=None, name=None,
-                             description=None, configuration=None):
+                             description=None, configuration=None,
+                             branches=None):
         """Create a BranchMergeQueue."""
         if name is None:
             name = unicode(self.getUniqueString('queue'))
@@ -1128,7 +1129,7 @@
                 self.getUniqueString('key'): self.getUniqueString('value')}))
 
         queue = getUtility(IBranchMergeQueueSource).new(
-            name, owner, registrant, description, configuration)
+            name, owner, registrant, description, configuration, branches)
         return queue
 
     def enableDefaultStackingForProduct(self, product, branch=None):