Merge lp:~wallyworld/launchpad/additional-affiliation-types-798764 into lp:launchpad

[Ian Booth]

[r=sinzui][bug=798764,820210,820212,820213] Add affiliation adapters for question, branch, specification, distro, product, distroseries, productseries

This branch adds to the affiliation adaptor to provide affiliation for other entity types:
- Specification
- Question
- Distribution
- DistroSeries
- ProductSeries
- Product

== Implementation ==

Add extra affiliation adaptors for the additional context types. Checks are done for:
owner
driver
security contact
bug supervisor

Some contexts have pillars eg BugTask has a product or distribution; a distroseries has a distribution. The context is checked first. If the context doesn't match on the given attribute (eg owner), then the pillar is checked. If there is no match on owner, then driver is checked etc.

I think this mp also covers the intent of bug 81692, although that bug talks about additional checks eg registrant. Do we consider the work done here sufficient to address that bug?

== Tests ==

Add a bunch of tests to test_pillaraffiliation

== Lint ==

Linting changed files:
  lib/lp/registry/configure.zcml
  lib/lp/registry/model/pillaraffiliation.py
  lib/lp/registry/tests/test_pillaraffiliation.py

[Curtis Hovey (sinzui)]

> === modified file 'lib/lp/registry/model/pillaraffiliation.py'
> --- lib/lp/registry/model/pillaraffiliation.py 2011-08-04 14:31:56 +0000
> +++ lib/lp/registry/model/pillaraffiliation.py 2011-08-04 14:32:17 +0000
...
> + def getPillar(self):
> + return self.context
> +
> + def getAffiliationBadge(self, person):
> + """ Return the affiliation information for a person given a context.
> +
> + The context is a Distribution, Product etc and is associated with a
> + pillar. Checks are done to see if the person is associated with the
> + context first (owner, driver etc) and if not, then the pillar.
> + """
> + pillar = self.getPillar()
> +
> + def checkAffiliation(capability, attribute, role):
> + # Check the affiliation defined by the specified capability on the
> + # context and then pillar. Capability is IHasOwner etc. WHatever
> + # matches first (context or pillar) is used for the display name.
> + affiliated_entity = None
> + capabilityProvidedBy = getattr(capability, 'providedBy')
> + if capabilityProvidedBy(self.context):
> + if person.inTeam(getattr(self.context, attribute)):
> + affiliated_entity = self.context.displayname
> + if (affiliated_entity is None and capabilityProvidedBy(pillar)):
> + if person.inTeam(getattr(pillar, attribute)):
> + affiliated_entity = pillar.displayname
> + if affiliated_entity is None:
> + return None
> + return affiliated_entity, role

I do not see why this is an inner function. This could be simpler too if
we decide that all we care about is product or distribution. We know how to
check owner, drivers, and other roles. The other kinds of items I
see returned, notably for specification and question are probably wrong.
We do not need the interface checks if we are certain we are getting a
distro or product.

I have some doubts about the universality of these checks. I think
owner and driver are universal. bug_supervisor and security contact are
only useful in bugs and branches cases that deal with privacy and security.
eg assigning a branch reviewer, bug assignee, subscriber.

Questions might care more about answer contacts which are more likely to
be assigned. Consider Ubuntu. The owners and drivers are rarely assigned.
when I assign a question, I care about the answer contact for the package
first, then the contacts for Ubuntu.

Specifications care about the people who are assignees, drafters, approvers,
and need feedback. In most cases these people are owners and drivers. There
is a rare case for the approver who is for the series goal...

The series is the problem. Maybe a separate branch becuase it is a rule
that may not prove very important. The series driver (release manager) is
the most important person for bugs that affect a series or blueprints with
a series goal. Those driver are assumed to be a subset of owner or drivers
who have the authority to define the work for a series. I happen to know
that This is not an issue for Ubuntu or any of our major pro...

review: Needs Information (code)

[Ian Booth (wallyworld)]

Thanks for the review. Clearly I'm missing some knowledge.

On 05/08/11 05:22, Curtis Hovey wrote:
> Review: Needs Information code
>> === modified file 'lib/lp/registry/model/pillaraffiliation.py'
>> --- lib/lp/registry/model/pillaraffiliation.py 2011-08-04 14:31:56 +0000
>> +++ lib/lp/registry/model/pillaraffiliation.py 2011-08-04 14:32:17 +0000
> ...
>> + def getPillar(self):
>> + return self.context
>> +
>> + def getAffiliationBadge(self, person):
>> + """ Return the affiliation information for a person given a context.
>> +
>> + The context is a Distribution, Product etc and is associated with a
>> + pillar. Checks are done to see if the person is associated with the
>> + context first (owner, driver etc) and if not, then the pillar.
>> + """
>> + pillar = self.getPillar()
>> +
>> + def checkAffiliation(capability, attribute, role):
>> + # Check the affiliation defined by the specified capability on the
>> + # context and then pillar. Capability is IHasOwner etc. WHatever
>> + # matches first (context or pillar) is used for the display name.
>> + affiliated_entity = None
>> + capabilityProvidedBy = getattr(capability, 'providedBy')
>> + if capabilityProvidedBy(self.context):
>> + if person.inTeam(getattr(self.context, attribute)):
>> + affiliated_entity = self.context.displayname
>> + if (affiliated_entity is None and capabilityProvidedBy(pillar)):
>> + if person.inTeam(getattr(pillar, attribute)):
>> + affiliated_entity = pillar.displayname
>> + if affiliated_entity is None:
>> + return None
>> + return affiliated_entity, role
>
> I do not see why this is an inner function. This could be simpler too if

Me either.

> we decide that all we care about is product or distribution. We know how to
> check owner, drivers, and other roles. The other kinds of items I
> see returned, notably for specification and question are probably wrong.
> We do not need the interface checks if we are certain we are getting a
> distro or product.
>

Will we always be getting a distro or product though? If I have a
Specification, wouldn't I want to possibly first see if the person in
question is affiliated with the specification itself and then check the
affiliation with the target (product/distro) only if the specification
check turned up empty?

> I have some doubts about the universality of these checks. I think
> owner and driver are universal. bug_supervisor and security contact are
> only useful in bugs and branches cases that deal with privacy and security.
> eg assigning a branch reviewer, bug assignee, subscriber.
>

This suggests we need another piece of context information to properly
determine the affiliation - the name of the attribute that is being
updated with the person, not just the person alone. So instead of saying
"we are associating person fred with bugtask 4 in some capacity" we are
saying "we are associating person fred with bugtask 4 as an assignee"
and that this distinction possibly affect...

[Ian Booth (wallyworld)]

The mp diff screwed up so I resubmitted and it looks better now.

I think I have addressed the main issues raised in the review.
- the base pillaraffiliation class performs owner and driver checks
- subclasses perform additional checks as required (eg bug supervisor, security contact for bugtasks)
- drivers attribute is used to get the drivers
- answer contacts used to check for question affiliation
- tests added for distroseries and productseries to test for driver affiliation
- tests added for questions to check for answer affiliation
- other test cleanup

The affiliation adapters don't take into account the attribute being set (eg assignee, approver etc). This can be done is another branch if required.

[Curtis Hovey (sinzui)]

Hi Ian.

I think this branch is good to land. I have a few remarks you may want to consider.

=== modified file 'lib/lp/registry/model/pillaraffiliation.py'
--- lib/lp/registry/model/pillaraffiliation.py 2011-08-04 13:56:55 +0000
+++ lib/lp/registry/model/pillaraffiliation.py 2011-08-05 06:14:28 +0000
...

> +@adapter(IBugTask)
> +class BugTaskPillarAffiliation(PillarAffiliation):
> + """An affiliation adapter for bug tasks."""
> + def getPillar(self):
> + return self.context.pillar
> +
> + def _getAffiliationDetails(self, person, pillar):
> + """ A person is affiliated with a bugtask based on (in order):
> + - owner of bugtask pillar
> + - driver of bugtask pillar
> + - bug supervisor of bugtask pillar
> + - security contact of bugtask pillar
> + """
> + result = super(BugTaskPillarAffiliation, self)._getAffiliationDetails(
> + person, pillar)
> + if result is not None:
> + return result
> + if person.inTeam(pillar.bug_supervisor):
> + return pillar.displayname, 'bug supervisor'
> + if person.inTeam(pillar.security_contact):
> + return pillar.displayname, 'security contact'

I think this will also work for branches. Could we do this as well?

@adapter(IBranch)
class BranchPillarAffiliation(BugTaskPillarAffiliation):
    """An affiliation adapter for branches."""

^ An extra class would not be be necessary using ZCML to register the adapter,
but we ouls still have two separate ZCML entried for both IBugTask
and IBranch.

> +@adapter(ISpecification)
> > +class SpecificationPillarAffiliation(PillarAffiliation):
> > + """An affiliation adapter for blueprints."""
> > + def getPillar(self):
> > + return (self.context.target)

You suggested that this adapter could check if the user is assigned a roll
for the specification. I think that could misinform users. Anyone can register
a specification and assign users to rolls. They are not in anyway affilliated
with the project. Most of Launchpad's visible blueprints are bogus, and they
where created by people other than ~launchpad. I think this implementation
is good.

> +@adapter(IQuestion)
> +class QuestionPillarAffiliation(PillarAffiliation):
> + """An affiliation adapter for questions."""
> + def getPillar(self):
> + return self.context.product or self.context.distribution
> +
> + def _getAffiliationDetails(self, person, pillar):
> + """ A person is affiliated with a question based on (in order):
> + - answer contact for question target
> + - owner of question target
> + - driver of question target
> + """
> + target = self.context.target
> + answer_contacts = target.answer_contacts
> + for answer_contact in answer_contacts:
> + if person.inTeam(answer_contact):
> + return target.displayname, 'answer contact'
> + return super(QuestionPillarAffiliation, self)._getAffiliationDetails(
> + person, pillar)

This looks a lot like code I wrote in 2007. In 2010 I updated security.py
to use an alternate approach that was much faster (fewer sql queries)...

review: Approve (code)

[Ian Booth (wallyworld)]

Thanks fir the review and suggestions.

I added a BranchAffiliationAdapter and updated the code in
QuestionAffiliationAdapter as per the suggestion in the review, plus
added new tests for the branch adapter and question adapter

On 06/08/11 00:21, Curtis Hovey wrote:
> Review: Approve code
> Hi Ian.
>
> I think this branch is good to land. I have a few remarks you may want to consider.
>
>
<snip>

[Ian Booth (wallyworld)]

I have put this new functionality behind a new eature flag: disclosure.personpicker_affiliation.enabled
Previously, this work was behind the existing disclosure.enhance_picker.enabled flag.

The reason is that there are questions over the performance in terms of the number of selects from the TeamParticipation table. The enhance_picker feature flag is on for production and I don't want to risk breaking lp.net with this new work.

=== modified file 'lib/lp/app/browser/tests/test_vocabulary.py'
--- lib/lp/app/browser/tests/test_vocabulary.py	2011-08-04 23:49:37 +0000
+++ lib/lp/app/browser/tests/test_vocabulary.py	2011-08-09 00:14:32 +0000
@@ -119,17 +119,19 @@
         self.assertEqual('http://launchpad.dev/~fnord', entry.alt_title_link)
         self.assertEqual(['Team members: 1'], entry.details)
 
-    def test_PersonPickerEntryAdapter_enhanced_picker_enabled_badges(self):
-        # The enhanced person picker provides affilliation information.
+    def test_PersonPickerEntryAdapter_personpicker_affiliation_badges(self):
+        # The person picker with affiliation enabled provides affilliation
+        # information.
         person = self.factory.makePerson(email='[e-mail]', name='snarf')
         project = self.factory.makeProduct(name='fnord', owner=person)
         bugtask = self.factory.makeBugTask(target=project)
         entry = IPickerEntry(person).getPickerEntry(
             bugtask, enhanced_picker_enabled=True,
-            picker_expander_enabled=True)
+            picker_expander_enabled=True,
+            personpicker_affiliation_enabled=True)
         self.assertEqual(1, len(entry.badges))
         self.assertEqual('/@@/product-badge', entry.badges[0]['url'])
-        self.assertEqual('Affiliated with Fnord', entry.badges[0]['alt'])
+        self.assertEqual('Fnord maintainer', entry.badges[0]['alt'])
 
 
 class TestPersonVocabulary:
@@ -171,8 +173,9 @@
         self.addCleanup(TestPersonVocabulary.setTestData, [])
 
     @staticmethod
-    def create_vocabulary_view(form):
-        context = getUtility(ILaunchpadRoot)
+    def create_vocabulary_view(form, context=None):
+        if context is None:
+            context = getUtility(ILaunchpadRoot)
         query_string = urlencode(form)
         return create_view(
             context, '+huge-vocabulary', form=form, query_string=query_string)
@@ -198,19 +201,25 @@
         feature_flag = {
             'disclosure.picker_enhancements.enabled': 'on',
             'disclosure.picker_expander.enabled': 'on',
+            'disclosure.personpicker_affiliation.enabled': 'on',
             }
         flags = FeatureFixture(feature_flag)
         flags.setUp()
         self.addCleanup(flags.cleanUp)
         team = self.factory.makeTeam(name='pting-team')
         TestPersonVocabulary.test_persons.append(team)
+        product = self.factory.makeProduct(owner=team)
+        bugtask = self.factory.makeBugTask(target=product)
         form = dict(name='TestPerson', search_text='pting-team')
-        view = self.create_vocabulary_view(form)
+        view = self.create_vocabulary_view(form, context=bugtask)
         result = simplejson.loads(view())
         expected = {
             "alt_title": team.name,
             "alt_title_link": "http://launchpad.dev/~%s" % team.name,
             "api_uri": "/~%s" % team.name,
+            "badges":
+                [{"alt": "%s maintainer" % product.displayname,
+                  "url": "/@@/product-badge"}],
             "css": "sprite team",
             "details": ['Team members: 1'],
             "link_css": "sprite new-window",
 
=== modified file 'lib/lp/app/browser/vocabulary.py'
--- lib/lp/app/browser/vocabulary.py	2011-08-04 15:18:04 +0000
+++ lib/lp/app/browser/vocabulary.py	2011-08-09 00:14:32 +0000
@@ -130,8 +130,9 @@
         extra = super(PersonPickerEntryAdapter, self).getPickerEntry(
             associated_object)
 
-        enhanced_picker_enabled = kwarg.get('enhanced_picker_enabled', False)
-        if enhanced_picker_enabled:
+        personpicker_affiliation_enabled = kwarg.get(
+                                    'personpicker_affiliation_enabled', False)
+        if personpicker_affiliation_enabled:
             # If the person is affiliated with the associated_object then we
             # can display a badge.
             badge_info = IHasAffiliation(
@@ -154,6 +155,7 @@
                     extra.description = '<email address hidden>'
 
         extra.metadata = get_person_picker_entry_metadata(person)
+        enhanced_picker_enabled = kwarg.get('enhanced_picker_enabled', False)
         if enhanced_picker_enabled:
             # We will display the person's name (launchpad id) after their
             # displayname.
@@ -242,6 +244,8 @@
             getFeatureFlag('disclosure.picker_enhancements.enabled'))
         self.picker_expander_enabled = bool(
             getFeatureFlag('disclosure.picker_expander.enabled'))
+        self.personpicker_affiliation_enabled = bool(
+            getFeatureFlag('disclosure.personpicker_affiliation.enabled'))
 
     def __call__(self):
         name = self.request.form.get('name')
@@ -287,7 +291,9 @@
             picker_entry = IPickerEntry(term.value).getPickerEntry(
                 self.context,
                 enhanced_picker_enabled=self.enhanced_picker_enabled,
-                picker_expander_enabled=self.picker_expander_enabled)
+                picker_expander_enabled=self.picker_expander_enabled,
+                personpicker_affiliation_enabled=
+                    self.personpicker_affiliation_enabled)
             if picker_entry.description is not None:
                 if len(picker_entry.description) > MAX_DESCRIPTION_LENGTH:
                     entry['description'] = (
 
=== modified file 'lib/lp/registry/configure.zcml'
--- lib/lp/registry/configure.zcml	2011-08-02 05:35:39 +0000
+++ lib/lp/registry/configure.zcml	2011-08-09 00:14:32 +0000
@@ -883,11 +883,36 @@
             permission="zope.Public"/>
 
         <adapter
+            for="lp.registry.interfaces.distribution.IDistribution"
+            factory="lp.registry.model.pillaraffiliation.PillarAffiliation"
+            />
+        <adapter
+            for="lp.registry.interfaces.product.IProduct"
+            factory="lp.registry.model.pillaraffiliation.PillarAffiliation"
+            />
+        <adapter
+            for="lp.bugs.interfaces.bugtask.IBugTask"
             factory="lp.registry.model.pillaraffiliation.BugTaskPillarAffiliation"
             />
-
-        <adapter
-            factory="lp.registry.model.pillaraffiliation.PillarAffiliation"
+        <adapter
+            for="lp.code.interfaces.branch.IBranch"
+            factory="lp.registry.model.pillaraffiliation.BranchPillarAffiliation"
+            />
+        <adapter
+            for="lp.answers.interfaces.question.IQuestion"
+            factory="lp.registry.model.pillaraffiliation.QuestionPillarAffiliation"
+            />
+        <adapter
+            for="lp.blueprints.interfaces.specification.ISpecification"
+            factory="lp.registry.model.pillaraffiliation.SpecificationPillarAffiliation"
+            />
+        <adapter
+            for="lp.registry.interfaces.distroseries.IDistroSeries"
+            factory="lp.registry.model.pillaraffiliation.DistroSeriesPillarAffiliation"
+            />
+        <adapter
+            for="lp.registry.interfaces.productseries.IProductSeries"
+            factory="lp.registry.model.pillaraffiliation.ProductSeriesPillarAffiliation"
             />
 
         <!-- Using
 
=== modified file 'lib/lp/registry/model/pillaraffiliation.py'
--- lib/lp/registry/model/pillaraffiliation.py	2011-08-04 13:56:55 +0000
+++ lib/lp/registry/model/pillaraffiliation.py	2011-08-09 00:14:32 +0000
@@ -29,8 +29,11 @@
     )
 
 from canonical.launchpad.interfaces.launchpad import IHasIcon
-from lp.bugs.interfaces.bugtask import IBugTask
+from lp.answers.interfaces.questionsperson import IQuestionsPerson
 from lp.registry.interfaces.distribution import IDistribution
+from lp.registry.interfaces.distributionsourcepackage import (
+    IDistributionSourcePackage,
+    )
 
 
 class IHasAffiliation(Interface):
@@ -51,7 +54,9 @@
 class PillarAffiliation(object):
     """Default affiliation adapter.
 
-    No affiliation is returned.
+    Subclasses may need to override getPillar() in order to provide the pillar
+    entity for which affiliation is to be determined. The default is just to
+    use the context object directly.
     """
 
     implements(IHasAffiliation)
@@ -59,32 +64,116 @@
     def __init__(self, context):
         self.context = context
 
-    def getAffiliationBadge(self, person):
-        return None
-
-
-# XXX: wallyworld 2011-05-24 bug=81692: TODO Work is required to determine
-# exactly what is required in terms of figuring out affiliation..
-
-@adapter(IBugTask)
-class BugTaskPillarAffiliation(PillarAffiliation):
-    """An affiliation adapter for bug tasks."""
-
-    def getAffiliationBadge(self, person):
-        pillar = self.context.pillar
-        affiliated = person.inTeam(pillar.owner)
-        if not affiliated:
+    def getPillar(self):
+        return self.context
+
+    def _getAffiliationDetails(self, person, pillar):
+        """ Return the affiliation information for a person, if any.
+
+        A person is affiliated with a pillar if they are in the list of
+        drivers or are the maintainer.
+        """
+        if person.inTeam(pillar.owner):
+            return pillar.displayname, 'maintainer'
+        for driver in pillar.drivers:
+            if person.inTeam(driver):
+                return pillar.displayname, 'driver'
+        return  None
+
+    def getAffiliationBadge(self, person):
+        """ Return the affiliation badge details for a person given a context.
+        """
+        pillar = self.getPillar()
+        affiliation_details = self._getAffiliationDetails(person, pillar)
+        if not affiliation_details:
             return None
 
-        def getIconUrl(context, default_url):
+        def getIconUrl(context, pillar, default_url):
             if IHasIcon.providedBy(context) and context.icon is not None:
                 icon_url = context.icon.getURL()
                 return icon_url
+            if IHasIcon.providedBy(pillar) and pillar.icon is not None:
+                icon_url = context.icon.getURL()
+                return icon_url
             return default_url
 
-        alt_text = "Affiliated with %s" % pillar.displayname
+        alt_text = "%s %s" % affiliation_details
         if IDistribution.providedBy(pillar):
-            icon_url = getIconUrl(pillar, "/@@/distribution-badge")
+            default_icon_url = "/@@/distribution-badge"
         else:
-            icon_url = getIconUrl(pillar, "/@@/product-badge")
+            default_icon_url = "/@@/product-badge"
+        icon_url = getIconUrl(self.context, pillar, default_icon_url)
         return BadgeDetails(icon_url, alt_text)
+
+
+class BugTaskPillarAffiliation(PillarAffiliation):
+    """An affiliation adapter for bug tasks."""
+    def getPillar(self):
+        return self.context.pillar
+
+    def _getAffiliationDetails(self, person, pillar):
+        """ A person is affiliated with a bugtask based on (in order):
+        - owner of bugtask pillar
+        - driver of bugtask pillar
+        - bug supervisor of bugtask pillar
+        - security contact of bugtask pillar
+        """
+        result = super(BugTaskPillarAffiliation, self)._getAffiliationDetails(
+            person, pillar)
+        if result is not None:
+            return result
+        if person.inTeam(pillar.bug_supervisor):
+            return pillar.displayname, 'bug supervisor'
+        if person.inTeam(pillar.security_contact):
+            return pillar.displayname, 'security contact'
+
+
+class BranchPillarAffiliation(BugTaskPillarAffiliation):
+    """An affiliation adapter for branches."""
+    def getPillar(self):
+        return self.context.product or self.context.distribution
+
+
+class DistroSeriesPillarAffiliation(PillarAffiliation):
+    """An affiliation adapter for distroseries."""
+    def getPillar(self):
+        return self.context.distribution
+
+
+class ProductSeriesPillarAffiliation(PillarAffiliation):
+    """An affiliation adapter for productseries."""
+    def getPillar(self):
+        return self.context.product
+
+
+class SpecificationPillarAffiliation(PillarAffiliation):
+    """An affiliation adapter for blueprints."""
+    def getPillar(self):
+        return (self.context.target)
+
+
+class QuestionPillarAffiliation(PillarAffiliation):
+    """An affiliation adapter for questions."""
+    def getPillar(self):
+        return self.context.product or self.context.distribution
+
+    def _getAffiliationDetails(self, person, pillar):
+        """ A person is affiliated with a question based on (in order):
+        - answer contact for question target
+        - owner of question target
+        - driver of question target
+        """
+        target = self.context.target
+        if IDistributionSourcePackage.providedBy(target):
+            question_targets = (target, target.distribution)
+        else:
+            question_targets = (target, )
+        questions_person = IQuestionsPerson(person)
+        for target in questions_person.getDirectAnswerQuestionTargets():
+            if target in question_targets:
+                return target.displayname, 'answer contact'
+        for target in questions_person.getTeamAnswerQuestionTargets():
+            if target in question_targets:
+                return target.displayname, 'answer contact'
+        return super(QuestionPillarAffiliation, self)._getAffiliationDetails(
+            person, pillar)
 
=== modified file 'lib/lp/registry/tests/test_pillaraffiliation.py'
--- lib/lp/registry/tests/test_pillaraffiliation.py	2011-08-04 13:56:55 +0000
+++ lib/lp/registry/tests/test_pillaraffiliation.py	2011-08-09 00:14:32 +0000
@@ -5,29 +5,451 @@
 
 __metaclass__ = type
 
+from storm.store import Store
+from testtools.matchers import Equals
+from zope.component import getUtility
+
 from canonical.testing.layers import DatabaseFunctionalLayer
 from lp.registry.model.pillaraffiliation import IHasAffiliation
-from lp.testing import TestCaseWithFactory
+from lp.services.worlddata.interfaces.language import ILanguageSet
+from lp.testing import (
+    person_logged_in,
+    StormStatementRecorder,
+    TestCaseWithFactory,
+    )
+from lp.testing.matchers import HasQueryCount
 
 
 class TestPillarAffiliation(TestCaseWithFactory):
 
     layer = DatabaseFunctionalLayer
 
-    def test_bugtask_distro_affiliation(self):
-        # A person who owns a bugtask distro is affiliated.
+    def _check_affiliated_with_distro(self, person, distro, role):
+        badge = IHasAffiliation(distro).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/distribution-badge", "Pting %s" % role), badge)
+
+    def test_distro_owner_affiliation(self):
+        # A person who owns a distro is affiliated.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(owner=person, name='pting')
+        self._check_affiliated_with_distro(person, distro, 'maintainer')
+
+    def test_distro_driver_affiliation(self):
+        # A person who is a distro driver is affiliated.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(driver=person, name='pting')
+        self._check_affiliated_with_distro(person, distro, 'driver')
+
+    def test_distro_team_driver_affiliation(self):
+        # A person who is a member of the distro driver team is affiliated.
+        person = self.factory.makePerson()
+        team = self.factory.makeTeam(members=[person])
+        distro = self.factory.makeDistribution(driver=team, name='pting')
+        self._check_affiliated_with_distro(person, distro, 'driver')
+
+    def test_no_distro_security_contact_affiliation(self):
+        # A person who is the security contact for a distro is not affiliated
+        # for simple distro affiliation checks.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(security_contact=person)
+        self.assertIs(
+            None, IHasAffiliation(distro).getAffiliationBadge(person))
+
+    def test_no_distro_bug_supervisor_affiliation(self):
+        # A person who is the bug supervisor for a distro is not affiliated
+        # for simple distro affiliation checks.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(bug_supervisor=person)
+        self.assertIs(
+            None, IHasAffiliation(distro).getAffiliationBadge(person))
+
+    def _check_affiliated_with_product(self, person, product, role):
+        badge = IHasAffiliation(product).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting %s" % role), badge)
+
+    def test_product_driver_affiliation(self):
+        # A person who is the driver for a product is affiliated.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(driver=person, name='pting')
+        self._check_affiliated_with_product(person, product, 'driver')
+
+    def test_product_team_driver_affiliation(self):
+        # A person who is a member of the product driver team is affiliated.
+        person = self.factory.makePerson()
+        team = self.factory.makeTeam(members=[person])
+        product = self.factory.makeProduct(driver=team, name='pting')
+        self._check_affiliated_with_product(person, product, 'driver')
+
+    def test_product_group_driver_affiliation(self):
+        # A person who is the driver for a product's group is affiliated.
+        person = self.factory.makePerson()
+        project = self.factory.makeProject(driver=person)
+        product = self.factory.makeProduct(project=project, name='pting')
+        self._check_affiliated_with_product(person, product, 'driver')
+
+    def test_no_product_security_contact_affiliation(self):
+        # A person who is the security contact for a product is is not
+        # affiliated for simple product affiliation checks.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(security_contact=person)
+        self.assertIs(
+            None, IHasAffiliation(product).getAffiliationBadge(person))
+
+    def test_no_product_bug_supervisor_affiliation(self):
+        # A person who is the bug supervisor for a product is is not
+        # affiliated for simple product affiliation checks.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(bug_supervisor=person)
+        self.assertIs(
+            None, IHasAffiliation(product).getAffiliationBadge(person))
+
+    def test_product_owner_affiliation(self):
+        # A person who owns a product is affiliated.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(owner=person, name='pting')
+        self._check_affiliated_with_product(person, product, 'maintainer')
+
+
+class _TestBugTaskorBranchMixin:
+
+    def test_distro_security_contact_affiliation(self):
+        # A person who is the security contact for a distro is affiliated.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(
+            security_contact=person, name='pting')
+        self._check_affiliated_with_distro(person, distro, 'security contact')
+
+    def test_distro_bug_supervisor_affiliation(self):
+        # A person who is the bug supervisor for a distro is affiliated.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(
+            bug_supervisor=person, name='pting')
+        self._check_affiliated_with_distro(person, distro, 'bug supervisor')
+
+    def test_product_security_contact_affiliation(self):
+        # A person who is the security contact for a distro is affiliated.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            security_contact=person, name='pting')
+        self._check_affiliated_with_product(
+            person, product, 'security contact')
+
+    def test_product_bug_supervisor_affiliation(self):
+        # A person who is the bug supervisor for a distro is affiliated.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            bug_supervisor=person, name='pting')
+        self._check_affiliated_with_product(person, product, 'bug supervisor')
+
+
+class TestBugTaskPillarAffiliation(_TestBugTaskorBranchMixin,
+                                   TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used(self):
+        bugtask = self.factory.makeBugTask()
+        badge = IHasAffiliation(bugtask)
+        self.assertEqual(bugtask.pillar, badge.getPillar())
+
+    def _check_affiliated_with_distro(self, person, target, role):
+        bugtask = self.factory.makeBugTask(target=target)
+        badge = IHasAffiliation(bugtask).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/distribution-badge", "Pting %s" % role), badge)
+
+    def _check_affiliated_with_product(self, person, target, role):
+        bugtask = self.factory.makeBugTask(target=target)
+        badge = IHasAffiliation(bugtask).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting %s" % role), badge)
+
+    def test_product_affiliation_query_count(self):
+        # Only 4 queries are expected, selects from:
+        # - Bug, BugTask, Product, Person
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(owner=person, name='pting')
+        bugtask = self.factory.makeBugTask(target=product)
+        Store.of(bugtask).invalidate()
+        with StormStatementRecorder() as recorder:
+            IHasAffiliation(bugtask).getAffiliationBadge(person)
+        self.assertThat(recorder, HasQueryCount(Equals(4)))
+
+    def test_distro_affiliation_query_count(self):
+        # Only 4 queries are expected, selects from:
+        # - Bug, BugTask, Distribution, Person
         person = self.factory.makePerson()
         distro = self.factory.makeDistribution(owner=person, name='pting')
         bugtask = self.factory.makeBugTask(target=distro)
-        badge = IHasAffiliation(bugtask).getAffiliationBadge(person)
-        self.assertEqual(
-            badge, ("/@@/distribution-badge", "Affiliated with Pting"))
-
-    def test_bugtask_product_affiliation(self):
-        # A person who owns a bugtask product is affiliated.
-        person = self.factory.makePerson()
-        product = self.factory.makeProduct(owner=person, name='pting')
-        bugtask = self.factory.makeBugTask(target=product)
-        badge = IHasAffiliation(bugtask).getAffiliationBadge(person)
-        self.assertEqual(
-            badge, ("/@@/product-badge", "Affiliated with Pting"))
+        Store.of(bugtask).invalidate()
+        with StormStatementRecorder() as recorder:
+            IHasAffiliation(bugtask).getAffiliationBadge(person)
+        self.assertThat(recorder, HasQueryCount(Equals(4)))
+
+
+class TestBranchPillarAffiliation(_TestBugTaskorBranchMixin,
+                                  TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used(self):
+        branch = self.factory.makeBranch()
+        badge = IHasAffiliation(branch)
+        self.assertEqual(branch.product, badge.getPillar())
+
+    def _check_affiliated_with_distro(self, person, target, role):
+        distroseries = self.factory.makeDistroSeries(distribution=target)
+        sp = self.factory.makeSourcePackage(distroseries=distroseries)
+        branch = self.factory.makeBranch(sourcepackage=sp)
+        badge = IHasAffiliation(branch).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/distribution-badge", "Pting %s" % role), badge)
+
+    def _check_affiliated_with_product(self, person, target, role):
+        branch = self.factory.makeBranch(product=target)
+        badge = IHasAffiliation(branch).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting %s" % role), badge)
+
+
+class TestDistroSeriesPillarAffiliation(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used(self):
+        series = self.factory.makeDistroSeries()
+        badge = IHasAffiliation(series)
+        self.assertEqual(series.distribution, badge.getPillar())
+
+    def test_driver_affiliation(self):
+        # A person who is the driver for a distroseries is affiliated.
+        # Here, the affiliation is with the distribution of the series.
+        owner = self.factory.makePerson()
+        driver = self.factory.makePerson()
+        distribution = self.factory.makeDistribution(
+            owner=owner, driver=driver, name='pting')
+        distroseries = self.factory.makeDistroSeries(
+            registrant=driver, distribution=distribution)
+        badge = IHasAffiliation(distroseries).getAffiliationBadge(driver)
+        self.assertEqual(
+            ("/@@/distribution-badge", "Pting driver"), badge)
+
+    def test_distro_driver_affiliation(self):
+        # A person who is the driver for a distroseries' distro is affiliated.
+        # Here, the affiliation is with the distribution of the series.
+        owner = self.factory.makePerson()
+        driver = self.factory.makePerson()
+        distribution = self.factory.makeDistribution(
+            owner=owner, driver=driver, name='pting')
+        distroseries = self.factory.makeDistroSeries(
+            registrant=owner, distribution=distribution)
+        badge = IHasAffiliation(distroseries).getAffiliationBadge(driver)
+        self.assertEqual(
+            ("/@@/distribution-badge", "Pting driver"), badge)
+
+
+class TestProductSeriesPillarAffiliation(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used(self):
+        series = self.factory.makeProductSeries()
+        badge = IHasAffiliation(series)
+        self.assertEqual(series.product, badge.getPillar())
+
+    def test_driver_affiliation(self):
+        # A person who is the driver for a productseries is affiliated.
+        # Here, the affiliation is with the product.
+        owner = self.factory.makePerson()
+        driver = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            owner=owner, driver=driver, name='pting')
+        productseries = self.factory.makeProductSeries(
+            owner=driver, product=product)
+        badge = IHasAffiliation(productseries).getAffiliationBadge(driver)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting driver"), badge)
+
+    def test_product_driver_affiliation(self):
+        # A person who is the driver for a productseries' product is
+        # affiliated. Here, the affiliation is with the product.
+        owner = self.factory.makePerson()
+        driver = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            owner=owner, driver=driver, name='pting')
+        productseries = self.factory.makeProductSeries(
+            owner=owner, product=product)
+        badge = IHasAffiliation(productseries).getAffiliationBadge(driver)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting driver"), badge)
+
+    def test_product_group_driver_affiliation(self):
+        # A person who is the driver for a productseries' product's group is
+        # affiliated. Here, the affiliation is with the product.
+        owner = self.factory.makePerson()
+        driver = self.factory.makePerson()
+        project = self.factory.makeProject(driver=driver)
+        product = self.factory.makeProduct(
+            owner=owner, project=project, name='pting')
+        productseries = self.factory.makeProductSeries(
+            owner=owner, product=product)
+        badge = IHasAffiliation(productseries).getAffiliationBadge(driver)
+        self.assertEqual(
+            ("/@@/product-badge", "Pting driver"), badge)
+
+
+class TestQuestionPillarAffiliation(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used_for_product(self):
+        product = self.factory.makeProduct()
+        question = self.factory.makeQuestion(target=product)
+        badge = IHasAffiliation(question)
+        self.assertEqual(question.product, badge.getPillar())
+
+    def test_correct_pillar_is_used_for_distribution(self):
+        distribution = self.factory.makeDistribution()
+        question = self.factory.makeQuestion(target=distribution)
+        badge = IHasAffiliation(question)
+        self.assertEqual(question.distribution, badge.getPillar())
+
+    def test_correct_pillar_is_used_for_distro_sourcepackage(self):
+        distribution = self.factory.makeDistribution()
+        distro_sourcepackage = self.factory.makeDistributionSourcePackage(
+            distribution=distribution)
+        owner = self.factory.makePerson()
+        question = self.factory.makeQuestion(
+            target=distro_sourcepackage, owner=owner)
+        badge = IHasAffiliation(question)
+        self.assertEqual(distribution, badge.getPillar())
+
+    def test_answer_contact_affiliation_for_distro(self):
+        # A person is affiliated if they are an answer contact for a distro
+        # target. Even if they also own the distro, the answer contact
+        # affiliation takes precedence.
+        answer_contact = self.factory.makePerson()
+        english = getUtility(ILanguageSet)['en']
+        answer_contact.addLanguage(english)
+        distro = self.factory.makeDistribution(owner=answer_contact)
+        with person_logged_in(answer_contact):
+            distro.addAnswerContact(answer_contact, answer_contact)
+        question = self.factory.makeQuestion(target=distro)
+        badge = IHasAffiliation(question).getAffiliationBadge(answer_contact)
+        self.assertEqual(
+            ("/@@/distribution-badge", "%s answer contact" %
+                distro.displayname), badge)
+
+    def test_answer_contact_affiliation_for_distro_sourcepackage(self):
+        # A person is affiliated if they are an answer contact for a dsp
+        # target. Even if they also own the distro, the answer contact
+        # affiliation takes precedence.
+        answer_contact = self.factory.makePerson()
+        english = getUtility(ILanguageSet)['en']
+        answer_contact.addLanguage(english)
+        distribution = self.factory.makeDistribution(owner=answer_contact)
+        distro_sourcepackage = self.factory.makeDistributionSourcePackage(
+            distribution=distribution)
+        with person_logged_in(answer_contact):
+            distro_sourcepackage.addAnswerContact(
+                answer_contact, answer_contact)
+        question = self.factory.makeQuestion(
+            target=distro_sourcepackage, owner=answer_contact)
+        badge = IHasAffiliation(question).getAffiliationBadge(answer_contact)
+        self.assertEqual(
+            ("/@@/distribution-badge", "%s answer contact" %
+                distro_sourcepackage.displayname), badge)
+
+    def test_answer_contact_affiliation_for_distro_sourcepackage_distro(self):
+        # A person is affiliated if they are an answer contact for a dsp
+        # target's distro. Even if they also own the distro, the answer
+        # contact affiliation takes precedence.
+        answer_contact = self.factory.makePerson()
+        english = getUtility(ILanguageSet)['en']
+        answer_contact.addLanguage(english)
+        distribution = self.factory.makeDistribution(owner=answer_contact)
+        distro_sourcepackage = self.factory.makeDistributionSourcePackage(
+            distribution=distribution)
+        with person_logged_in(answer_contact):
+            distribution.addAnswerContact(answer_contact, answer_contact)
+        question = self.factory.makeQuestion(
+            target=distro_sourcepackage, owner=answer_contact)
+        badge = IHasAffiliation(question).getAffiliationBadge(answer_contact)
+        self.assertEqual(
+            ("/@@/distribution-badge", "%s answer contact" %
+                distribution.displayname), badge)
+
+    def test_answer_contact_affiliation_for_product(self):
+        # A person is affiliated if they are an answer contact for a product
+        # target. Even if they also own the product, the answer contact
+        # affiliation takes precedence.
+        answer_contact = self.factory.makePerson()
+        english = getUtility(ILanguageSet)['en']
+        answer_contact.addLanguage(english)
+        product = self.factory.makeProduct(owner=answer_contact)
+        with person_logged_in(answer_contact):
+            product.addAnswerContact(answer_contact, answer_contact)
+        question = self.factory.makeQuestion(target=product)
+        badge = IHasAffiliation(question).getAffiliationBadge(answer_contact)
+        self.assertEqual(
+            ("/@@/product-badge", "%s answer contact" %
+                product.displayname), badge)
+
+    def test_product_affiliation(self):
+        # A person is affiliated if they are affiliated with the product.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(owner=person)
+        question = self.factory.makeQuestion(target=product)
+        badge = IHasAffiliation(question).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/product-badge", "%s maintainer" %
+                product.displayname), badge)
+
+    def test_distribution_affiliation(self):
+        # A person is affiliated if they are affiliated with the distribution.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(owner=person)
+        question = self.factory.makeQuestion(target=distro)
+        badge = IHasAffiliation(question).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/distribution-badge", "%s maintainer" %
+                distro.displayname), badge)
+
+
+class TestSpecificationPillarAffiliation(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_correct_pillar_is_used_for_product(self):
+        product = self.factory.makeProduct()
+        specification = self.factory.makeSpecification(product=product)
+        badge = IHasAffiliation(specification)
+        self.assertEqual(specification.product, badge.getPillar())
+
+    def test_correct_pillar_is_used_for_distribution(self):
+        distro = self.factory.makeDistribution()
+        specification = self.factory.makeSpecification(distribution=distro)
+        badge = IHasAffiliation(specification)
+        self.assertEqual(specification.distribution, badge.getPillar())
+
+    def test_product_affiliation(self):
+        # A person is affiliated if they are affiliated with the pillar.
+        person = self.factory.makePerson()
+        product = self.factory.makeProduct(owner=person)
+        specification = self.factory.makeSpecification(product=product)
+        badge = IHasAffiliation(specification).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/product-badge", "%s maintainer" %
+                product.displayname), badge)
+
+    def test_distribution_affiliation(self):
+        # A person is affiliated if they are affiliated with the distribution.
+        person = self.factory.makePerson()
+        distro = self.factory.makeDistribution(owner=person)
+        specification = self.factory.makeSpecification(distribution=distro)
+        badge = IHasAffiliation(specification).getAffiliationBadge(person)
+        self.assertEqual(
+            ("/@@/distribution-badge", "%s maintainer" %
+                distro.displayname), badge)
 
=== modified file 'lib/lp/services/features/flags.py'
--- lib/lp/services/features/flags.py	2011-08-05 06:40:47 +0000
+++ lib/lp/services/features/flags.py	2011-08-09 00:14:32 +0000
@@ -121,6 +121,10 @@
      'boolean',
      ('Enables the expanding of extra details in the person picker.'),
      ''),
+    ('disclosure.personpicker_affiliation.enabled',
+     'boolean',
+     ('Enables display of affiliation details in the person picker.'),
+     ''),
     ('disclosure.person_affiliation_rank.enabled',
      'boolean',
      ('Enables ranking by pillar affiliation in the person picker.'),
 
=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2011-08-05 06:40:47 +0000
+++ lib/lp/testing/factory.py	2011-08-09 00:14:32 +0000
@@ -954,7 +954,7 @@
         licenses=None, owner=None, registrant=None,
         title=None, summary=None, official_malone=None,
         translations_usage=None, bug_supervisor=None,
-        driver=None):
+        driver=None, security_contact=None):
         """Create and return a new, arbitrary Product."""
         if owner is None:
             owner = self.makePerson()
@@ -990,6 +990,8 @@
             naked_product.bug_supervisor = bug_supervisor
         if driver is not None:
             naked_product.driver = driver
+        if security_contact is not None:
+            naked_product.security_contact = security_contact
         return product
 
     def makeProductSeries(self, product=None, name=None, owner=None,
@@ -1023,7 +1025,7 @@
         return ProxyFactory(series)
 
     def makeProject(self, name=None, displayname=None, title=None,
-                    homepageurl=None, summary=None, owner=None,
+                    homepageurl=None, summary=None, owner=None, driver=None,
                     description=None):
         """Create and return a new, arbitrary ProjectGroup."""
         if owner is None:
@@ -1038,7 +1040,7 @@
             description = self.getUniqueString('description')
         if title is None:
             title = self.getUniqueString('title')
-        return getUtility(IProjectGroupSet).new(
+        project = getUtility(IProjectGroupSet).new(
             name=name,
             displayname=displayname,
             title=title,
@@ -1046,6 +1048,9 @@
             summary=summary,
             description=description,
             owner=owner)
+        if driver is not None:
+            removeSecurityProxy(project).driver = driver
+        return project
 
     def makeSprint(self, title=None, name=None):
         """Make a sprint."""
@@ -2324,9 +2329,10 @@
 
     def makeDistribution(self, name=None, displayname=None, owner=None,
                          registrant=None, members=None, title=None,
-                         aliases=None, bug_supervisor=None,
-                         publish_root_dir=None, publish_base_url=None,
-                         publish_copy_base_url=None, no_pubconf=False):
+                         aliases=None, bug_supervisor=None, driver=None,
+                         security_contact=None, publish_root_dir=None,
+                         publish_base_url=None, publish_copy_base_url=None,
+                         no_pubconf=False):
         """Make a new distribution."""
         if name is None:
             name = self.getUniqueString(prefix="distribution")
@@ -2346,11 +2352,15 @@
         distro = getUtility(IDistributionSet).new(
             name, displayname, title, description, summary, domainname,
             members, owner, registrant)
+        naked_distro = removeSecurityProxy(distro)
         if aliases is not None:
-            removeSecurityProxy(distro).setAliases(aliases)
+            naked_distro.setAliases(aliases)
+        if driver is not None:
+            naked_distro.driver = driver
         if bug_supervisor is not None:
-            naked_distro = removeSecurityProxy(distro)
             naked_distro.bug_supervisor = bug_supervisor
+        if security_contact is not None:
+            naked_distro.security_contact = security_contact
         if not no_pubconf:
             self.makePublisherConfig(
                 distro, publish_root_dir, publish_base_url,