def getPickerEntries(self, term_values, context_object, **kwarg):
"""See `IPickerEntrySource`"""
picker_entries = (super(PersonPickerEntrySourceAdapter,
self).getPickerEntries(term_values,
context_object))
affiliated_context = IHasAffiliation(context_object, None)
if affiliated_context is not None:
# If a person is affiliated with the associated_object then we
# can display a badge.
badges = affiliated_context.getAffiliationBadges(term_values)
for picker_entry, badges in izip(picker_entries, badges):
picker_entry.badges = []
for badge_info in badges:
picker_entry.badges.append(
dict(url=badge_info.url,
label=badge_info.label,
role=badge_info.role))
for person, picker_entry in izip(term_values, picker_entries):
picker_entry.details = []
if person.preferredemail is not None:
if person.hide_email_addresses:
picker_entry.description = '<email address hidden>'
else:
try:
picker_entry.description = person.preferredemail.email
except Unauthorized:
picker_entry.description = '<email address hidden>'
picker_entry.metadata = get_person_picker_entry_metadata(person)
# We will display the person's name (launchpad id) after their
# displayname.
picker_entry.alt_title = person.name
# We will linkify the person's name so it can be clicked to
# open the page for that person.
picker_entry.alt_title_link = canonical_url(person,
rootsite='mainsite')
# We will display the person's irc nick(s) after their email
# address in the description text.
irc_nicks = None
if person.ircnicknames:
irc_nicks = ", ".join([
IRCNicknameFormatterAPI(ircid).displayname()
for ircid in person.ircnicknames
])
if irc_nicks:
picker_entry.details.append(irc_nicks)
if person.is_team:
picker_entry.details.append('Team members: %s' %
person.all_member_count)
else:
picker_entry.details.append(
'Member since %s' %
DateTimeFormatterAPI(person.datecreated).date())
return picker_entries
def test_correct_pillars_are_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)
adapter = IHasAffiliation(question)
self.assertEqual([distribution], adapter.getPillars())
def test_correct_pillars_are_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)
adapter = IHasAffiliation(question)
self.assertEqual([distribution], adapter.getPillars())
def getPickerEntries(self, term_values, context_object, **kwarg):
"""See `IPickerEntrySource`"""
picker_entries = (
super(PersonPickerEntrySourceAdapter, self)
.getPickerEntries(term_values, context_object))
affiliated_context = IHasAffiliation(context_object, None)
if affiliated_context is not None:
# If a person is affiliated with the associated_object then we
# can display a badge.
badges = affiliated_context.getAffiliationBadges(term_values)
for picker_entry, badges in izip(picker_entries, badges):
picker_entry.badges = []
for badge_info in badges:
picker_entry.badges.append(
dict(url=badge_info.url,
label=badge_info.label,
role=badge_info.role))
for person, picker_entry in izip(term_values, picker_entries):
picker_entry.details = []
if person.preferredemail is not None:
if person.hide_email_addresses:
picker_entry.description = '<email address hidden>'
else:
try:
picker_entry.description = person.preferredemail.email
except Unauthorized:
picker_entry.description = '<email address hidden>'
picker_entry.metadata = get_person_picker_entry_metadata(person)
# We will display the person's name (launchpad id) after their
# displayname.
picker_entry.alt_title = person.name
# We will linkify the person's name so it can be clicked to
# open the page for that person.
picker_entry.alt_title_link = canonical_url(
person, rootsite='mainsite')
# We will display the person's irc nick(s) after their email
# address in the description text.
irc_nicks = None
if person.ircnicknames:
irc_nicks = ", ".join(
[IRCNicknameFormatterAPI(ircid).displayname()
for ircid in person.ircnicknames])
if irc_nicks:
picker_entry.details.append(irc_nicks)
if person.is_team:
picker_entry.details.append(
'Team members: %s' % person.all_member_count)
else:
picker_entry.details.append(
'Member since %s' % DateTimeFormatterAPI(
person.datecreated).date())
return picker_entries
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)
[badges] = IHasAffiliation(branch).getAffiliationBadges([person])
self.assertEqual(
("/@@/distribution-badge", "Pting", role), badges[0])
def _check_affiliated_with_product(self, person, target, role):
branch = self.factory.makeBranch(product=target)
with person_logged_in(branch.owner):
branch.reviewer = person
[badges] = IHasAffiliation(branch).getAffiliationBadges([person])
self.assertEqual(
("/@@/product-badge", "Pting", role), badges[0])
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.assertEqual(
[], IHasAffiliation(distro).getAffiliationBadges([person])[0])
def test_answer_contact_affiliation_for_distro_sourcepackage(self):
# A person is affiliated if they are an answer contact for a dsp
# target.
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)
[badges] = (
IHasAffiliation(question).getAffiliationBadges([answer_contact]))
self.assertEqual(
("/@@/distribution-badge", distribution.displayname,
"maintainer"), badges[0])
self.assertEqual(
("/@@/distribution-badge", distribution.displayname,
"driver"), badges[1])
self.assertEqual(
("/@@/distribution-badge", distro_sourcepackage.displayname,
"answer contact"), badges[2])
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.assertEqual(
[], IHasAffiliation(product).getAffiliationBadges([person])[0])
def test_product_affiliation_query_count(self):
# Only 2 queries are expected, selects from:
# - Product, Person
person = self.factory.makePerson()
product = self.factory.makeProduct(owner=person, name='pting')
Store.of(product).invalidate()
with StormStatementRecorder() as recorder:
IHasAffiliation(product).getAffiliationBadges([person])
self.assertThat(recorder, HasQueryCount(Equals(4)))
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)
[badges] = IHasAffiliation(question).getAffiliationBadges([person])
self.assertEqual(
("/@@/product-badge", product.displayname, "maintainer"),
badges[0])
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)
[badges] = IHasAffiliation(question).getAffiliationBadges([person])
self.assertEqual(
("/@@/distribution-badge", distro.displayname, "maintainer"),
badges[0])
def test_product_badge_icon(self):
# A product's icon is used for the badge if present.
person = self.factory.makePerson()
icon = self.factory.makeLibraryFileAlias(
filename='smurf.png', content_type='image/png')
product = self.factory.makeProduct(
owner=person, name='pting', icon=icon)
[badges] = IHasAffiliation(product).getAffiliationBadges([person])
self.assertEqual((icon.getURL(), "Pting", "maintainer"), badges[0])
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)
[badges] = (
IHasAffiliation(specification).getAffiliationBadges([person]))
self.assertEqual(
("/@@/product-badge", product.displayname, "maintainer"),
badges[0])
def test_distro_affiliation_query_count(self):
# Only 2 business queries are expected, selects from:
# - Distribution, Person
# plus an additional query to create a PublisherConfig record.
person = self.factory.makePerson()
distro = self.factory.makeDistribution(owner=person, name='pting')
Store.of(distro).invalidate()
with StormStatementRecorder() as recorder:
IHasAffiliation(distro).getAffiliationBadges([person])
self.assertThat(recorder, HasQueryCount(Equals(3)))
def test_pillar_badge_icon(self):
# A pillar's icon is used for the badge if the context has no icon.
person = self.factory.makePerson()
icon = self.factory.makeLibraryFileAlias(
filename='smurf.png', content_type='image/png')
product = self.factory.makeProduct(
owner=person, name='pting', icon=icon)
bugtask = self.factory.makeBugTask(target=product)
[badges] = IHasAffiliation(bugtask).getAffiliationBadges([person])
self.assertEqual((icon.getURL(), "Pting", "maintainer"), badges[0])
def test_distro_affiliation_multiple_people(self):
# A collection of people associated with a distro are affiliated.
people = [self.factory.makePerson() for x in range(3)]
distro = self.factory.makeDistribution(owner=people[0],
driver=people[1],
name='pting')
person_badges = IHasAffiliation(distro).getAffiliationBadges(people)
self.assertEqual([("/@@/distribution-badge", "Pting", "maintainer")],
person_badges[0])
self.assertEqual([("/@@/distribution-badge", "Pting", "driver")],
person_badges[1])
self.assertEqual([], person_badges[2])
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)
[badges] = (
IHasAffiliation(productseries).getAffiliationBadges([driver]))
self.assertEqual(
("/@@/product-badge", "Pting", "driver"), badges[0])
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)
[badges] = IHasAffiliation(
distroseries).getAffiliationBadges([driver])
self.assertEqual(
("/@@/distribution-badge", "Pting", "driver"), badges[0])
def test_answer_contact_affiliation_for_product(self):
# A person is affiliated if they are an answer contact for a product
# target.
answer_contact = self.factory.makePerson()
english = getUtility(ILanguageSet)['en']
answer_contact.addLanguage(english)
product = self.factory.makeProduct()
with person_logged_in(answer_contact):
product.addAnswerContact(answer_contact, answer_contact)
question = self.factory.makeQuestion(target=product)
[badges] = (
IHasAffiliation(question).getAffiliationBadges([answer_contact]))
self.assertEqual(
("/@@/product-badge", product.displayname, "answer contact"),
badges[0])
def test_affiliated_with_multiple_bugtasks(self):
# When a bugtask belongs to a bug which has other bugtasks, all such
# bugtasks are checked for affiliation.
person = self.factory.makePerson()
bug = self.factory.makeBug()
expected_affiliations = []
for x in range(3):
bug_supervisor = None
if x == 0:
bug_supervisor = person
product = self.factory.makeProduct(
owner=person, bug_supervisor=bug_supervisor)
self.factory.makeBugTask(bug=bug, target=product)
expected_affiliations.append(
("/@@/product-badge", product.displayname, "maintainer"))
expected_affiliations.append(
("/@@/product-badge", product.displayname, "driver"))
if x == 0:
expected_affiliations.append(
("/@@/product-badge",
product.displayname, "bug supervisor"))
[badges] = IHasAffiliation(
bug.default_bugtask).getAffiliationBadges([person])
self.assertContentEqual(expected_affiliations, badges)
def _check_affiliated_with_distro(self, person, distro, role):
[badges] = IHasAffiliation(distro).getAffiliationBadges([person])
self.assertEqual(
("/@@/distribution-badge", "Pting", role), badges[0])
def test_correct_pillars_are_used_for_distribution(self):
distro = self.factory.makeDistribution()
specification = self.factory.makeSpecification(distribution=distro)
adapter = IHasAffiliation(specification)
self.assertEqual([specification.distribution], adapter.getPillars())
def test_correct_pillars_are_used_for_distribution(self):
distribution = self.factory.makeDistribution()
question = self.factory.makeQuestion(target=distribution)
adapter = IHasAffiliation(question)
self.assertEqual([question.distribution], adapter.getPillars())
def test_getBranch(self):
# The branch is the context.
branch = self.factory.makeBranch()
adapter = IHasAffiliation(branch)
self.assertEqual(branch, adapter.getBranch())
def test_personal_branches_have_no_pillars(self):
branch = self.factory.makeBranch(product=None)
adapter = IHasAffiliation(branch)
self.assertEqual([], adapter.getPillars())
def test_getBranch(self):
# The branch is the context.
branch = self.factory.makeBranch()
adapter = IHasAffiliation(branch)
self.assertEqual(branch, adapter.getBranch())
def test_getBranch(self):
# The code review vote's target branch is the branch.
branch = self.factory.makeBranch()
vote = self.makeCodeReviewVote(branch)
adapter = IHasAffiliation(vote)
self.assertEqual(branch, adapter.getBranch())
def test_correct_pillars_are_used_for_product(self):
product = self.factory.makeProduct()
question = self.factory.makeQuestion(target=product)
adapter = IHasAffiliation(question)
self.assertEqual([question.product], adapter.getPillars())
def test_correct_pillars_are_used_for_distribution(self):
distribution = self.factory.makeDistribution()
question = self.factory.makeQuestion(target=distribution)
adapter = IHasAffiliation(question)
self.assertEqual([question.distribution], adapter.getPillars())
def test_correct_pillars_are_used_for_distribution(self):
distro = self.factory.makeDistribution()
specification = self.factory.makeSpecification(distribution=distro)
adapter = IHasAffiliation(specification)
self.assertEqual([specification.distribution], adapter.getPillars())
def test_correct_pillars_are_used_for_product(self):
product = self.factory.makeProduct()
specification = self.factory.makeSpecification(product=product)
adapter = IHasAffiliation(specification)
self.assertEqual([specification.product], adapter.getPillars())
def test_correct_pillars_are_used_for_product(self):
product = self.factory.makeProduct()
question = self.factory.makeQuestion(target=product)
adapter = IHasAffiliation(question)
self.assertEqual([question.product], adapter.getPillars())
def test_correct_pillars_are_used(self):
series = self.factory.makeDistroSeries()
adapter = IHasAffiliation(series)
self.assertEqual([series.distribution], adapter.getPillars())
def test_correct_pillars_are_used(self):
series = self.factory.makeDistroSeries()
adapter = IHasAffiliation(series)
self.assertEqual([series.distribution], adapter.getPillars())
def test_correct_pillars_are_used_for_product(self):
product = self.factory.makeProduct()
specification = self.factory.makeSpecification(product=product)
adapter = IHasAffiliation(specification)
self.assertEqual([specification.product], adapter.getPillars())
def test_correct_pillars_are_used(self):
series = self.factory.makeProductSeries()
adapter = IHasAffiliation(series)
self.assertEqual([series.product], adapter.getPillars())
def test_correct_pillars_are_used(self):
branch = self.factory.makeBranch()
vote = self.makeCodeReviewVote(branch)
adapter = IHasAffiliation(vote)
self.assertEqual([branch.product], adapter.getPillars())
def test_correct_pillars_are_used(self):
branch = self.factory.makeBranch()
vote = self.makeCodeReviewVote(branch)
adapter = IHasAffiliation(vote)
self.assertEqual([branch.product], adapter.getPillars())
def test_getBranch(self):
# The code review vote's target branch is the branch.
branch = self.factory.makeBranch()
vote = self.makeCodeReviewVote(branch)
adapter = IHasAffiliation(vote)
self.assertEqual(branch, adapter.getBranch())
def test_correct_pillars_are_used(self):
series = self.factory.makeProductSeries()
adapter = IHasAffiliation(series)
self.assertEqual([series.product], adapter.getPillars())
def _check_affiliated_with_product(self, person, product, role):
[badges] = IHasAffiliation(product).getAffiliationBadges([person])
self.assertEqual(("/@@/product-badge", "Pting", role), badges[0])
def test_correct_pillars_are_used(self):
bugtask = self.factory.makeBugTask()
adapter = IHasAffiliation(bugtask)
pillars = [bugtask.pillar for bugtask in bugtask.bug.bugtasks]
self.assertEqual(pillars, adapter.getPillars())
