Merge lp:~wgrant/launchpad/bug-restrict-type into lp:launchpad

[William Grant]

Reject bug target or information type changes that would violate sharing policies.

This branch prevents bugs from transitioning to an information type that's illegal in their targets, or affecting a new target that disallows their information type.

I replaced the exceptions BranchCannotChangeInformationType and BugCannotBePrivate with a generic CannotChangeInformationType. transitionToInformationType checks directly that the new type is permitted, and createBug/createTask/transitionToTarget all use validate_target to confirm that the type is permitted in the new target.

I also extended the Proprietary single-pillar checks to Embargoed, as they were intended to have been from the start.

[Steve Kowalik (stevenk)]

This looks like excellent work. I have one mis-giving:

373 - BranchCannotChangeInformationType,
374 - branch.setPrivate,
375 - True, branch.owner)
376 + CannotChangeInformationType,
377 + branch.setPrivate, True, branch.owner)

395 - BranchCannotChangeInformationType,
396 - branch.setPrivate,
397 - False, branch.owner)
398 + CannotChangeInformationType,
399 + branch.setPrivate, False, branch.owner)

Given you've added text to the branch cases that raise CannotChangeInformationType, can you flip these tests to making use of self.assertRaisesWithContent() and make certain the exception text is right.

review: Approve (code)

=== modified file 'lib/lp/bugs/browser/bugalsoaffects.py'
--- lib/lp/bugs/browser/bugalsoaffects.py	2012-06-29 08:40:05 +0000
+++ lib/lp/bugs/browser/bugalsoaffects.py	2012-08-30 06:21:19 +0000
@@ -174,7 +174,7 @@
     def validateStep(self, data):
         if data.get('product'):
             try:
-                validate_target(self.context.bug, data.get('product'))
+                validate_new_target(self.context.bug, data.get('product'))
             except IllegalTarget as e:
                 self.setFieldError('product', e[0])
             return
 
=== modified file 'lib/lp/bugs/browser/bugtask.py'
--- lib/lp/bugs/browser/bugtask.py	2012-08-29 06:24:05 +0000
+++ lib/lp/bugs/browser/bugtask.py	2012-08-30 06:21:19 +0000
@@ -222,7 +222,10 @@
 from lp.bugs.model.bugtasksearch import orderby_expression
 from lp.code.interfaces.branchcollection import IAllBranches
 from lp.layers import FeedsLayer
-from lp.registry.enums import InformationType
+from lp.registry.enums import (
+    InformationType,
+    PROPRIETARY_INFORMATION_TYPES,
+    )
 from lp.registry.interfaces.distribution import (
     IDistribution,
     IDistributionSet,
@@ -699,7 +702,6 @@
             cancel_url = canonical_url(self.context)
         return cancel_url
 
-
     @cachedproperty
     def is_duplicate_active(self):
         active = True
@@ -3892,18 +3894,12 @@
     def canAddProjectTask(self):
         """Can a new bug task on a project be added to this bug?
 
-        If a bug has any bug tasks already, were it to be private, it cannot
-        be marked as also affecting any other project, so return False.
-
-        Note: this check is currently only relevant if a bug is private.
-        Eventually, even public bugs will have this restriction too. So what
-        happens now is that this API is used by the tales to add a class
-        called 'disallow-private' to the Also Affects Project link. A css rule
-        is used to hide the link when body.private is True.
-
+        If a bug has any bug tasks already, were it to be Proprietary or
+        Embargoed, it cannot be marked as also affecting any other
+        project, so return False.
         """
         bug = self.context
-        if bug.information_type != InformationType.PROPRIETARY:
+        if bug.information_type not in PROPRIETARY_INFORMATION_TYPES:
             return True
         return len(bug.bugtasks) == 0
 
@@ -3911,20 +3907,14 @@
         """Can a new bug task on a src pkg be added to this bug?
 
         If a bug has any existing bug tasks on a project, were it to
-        be private, then it cannot be marked as affecting a package,
-        so return False.
+        be Proprietary or Embargoed, then it cannot be marked as
+        affecting a package, so return False.
 
         A task on a given package may still be illegal to add, but
         this will be caught when bug.addTask() is attempted.
-
-        Note: this check is currently only relevant if a bug is private.
-        Eventually, even public bugs will have this restriction too. So what
-        happens now is that this API is used by the tales to add a class
-        called 'disallow-private' to the Also Affects Package link. A css rule
-        is used to hide the link when body.private is True.
         """
         bug = self.context
-        if bug.information_type != InformationType.PROPRIETARY:
+        if bug.information_type not in PROPRIETARY_INFORMATION_TYPES:
             return True
         for pillar in bug.affected_pillars:
             if IProduct.providedBy(pillar):
 
=== modified file 'lib/lp/bugs/browser/tests/test_bug_views.py'
--- lib/lp/bugs/browser/tests/test_bug_views.py	2012-08-29 06:57:53 +0000
+++ lib/lp/bugs/browser/tests/test_bug_views.py	2012-08-30 06:21:19 +0000
@@ -84,8 +84,11 @@
         # We expect that both Also Affects links (for project and distro) are
         # disallowed.
         owner = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
         bug = self.factory.makeBug(
-            information_type=InformationType.PROPRIETARY, owner=owner)
+            target=product, owner=owner,
+            information_type=InformationType.PROPRIETARY)
         url = canonical_url(bug, rootsite="bugs")
         browser = self.getUserBrowser(url, user=owner)
         also_affects = find_tag_by_id(
@@ -101,10 +104,14 @@
         # We expect that only the Also Affects Project link is disallowed.
         distro = self.factory.makeDistribution()
         owner = self.factory.makePerson()
-        self.factory.makeAccessPolicy(pillar=distro)
+        # XXX wgrant 2012-08-30 bug=1041002: Distributions don't have
+        # sharing policies yet, so it isn't possible legitimately create
+        # a Proprietary distro bug.
         bug = self.factory.makeBug(
             target=distro,
-            information_type=InformationType.PROPRIETARY, owner=owner)
+            information_type=InformationType.PRIVATESECURITY, owner=owner)
+        removeSecurityProxy(bug).information_type = (
+            InformationType.PROPRIETARY)
         url = canonical_url(bug, rootsite="bugs")
         browser = self.getUserBrowser(url, user=owner)
         also_affects = find_tag_by_id(
 
=== modified file 'lib/lp/bugs/browser/tests/test_bugs.py'
--- lib/lp/bugs/browser/tests/test_bugs.py	2012-08-29 03:19:38 +0000
+++ lib/lp/bugs/browser/tests/test_bugs.py	2012-08-30 06:21:19 +0000
@@ -222,7 +222,7 @@
 
     def test_createBug_private_bug_private_bugs_false(self):
         # createBug() adapts a kwarg to InformationType if one is is not None.
-        project = self.factory.makeProduct(
+        project = self.factory.makeLegacyProduct(
             licenses=[License.OTHER_PROPRIETARY])
         with person_logged_in(project.owner):
             project.setPrivateBugs(False, project.owner)
 
=== modified file 'lib/lp/bugs/browser/tests/test_bugtask.py'
--- lib/lp/bugs/browser/tests/test_bugtask.py	2012-08-28 09:36:42 +0000
+++ lib/lp/bugs/browser/tests/test_bugtask.py	2012-08-30 06:21:19 +0000
@@ -58,7 +58,10 @@
     FeedsLayer,
     setFirstLayer,
     )
-from lp.registry.enums import InformationType
+from lp.registry.enums import (
+    BugSharingPolicy,
+    InformationType,
+    )
 from lp.registry.interfaces.person import PersonVisibility
 from lp.services.config import config
 from lp.services.database.constants import UTC_NOW
@@ -1105,8 +1108,11 @@
         # A bug affecting a project cannot also affect another project or
         # package.
         owner = self.factory.makePerson()
+        product = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY_OR_PUBLIC)
         bug = self.factory.makeBug(
-            information_type=InformationType.PROPRIETARY, owner=owner)
+            target=product, owner=owner,
+            information_type=InformationType.PROPRIETARY)
         with person_logged_in(owner):
             view = self._createView(bug)
             self.assertFalse(view.canAddProjectTask())
@@ -1120,31 +1126,14 @@
         # could affect another package.
         distro = self.factory.makeDistribution()
         owner = self.factory.makePerson()
-        self.factory.makeAccessPolicy(pillar=distro)
         bug = self.factory.makeBug(
             target=distro, owner=owner,
-            information_type=InformationType.PROPRIETARY)
-        with person_logged_in(owner):
-            view = self._createView(bug)
-            self.assertFalse(view.canAddProjectTask())
-            self.assertTrue(view.canAddPackageTask())
-            bug.transitionToInformationType(InformationType.USERDATA, owner)
-            self.assertTrue(view.canAddProjectTask())
-            self.assertTrue(view.canAddPackageTask())
-
-    def test_sourcepkg_bug_cannot_affect_project(self):
-        # A bug affecting a source pkg cannot also affect another project but
-        # it could affect another package.
-        distro = self.factory.makeDistribution()
-        distroseries = self.factory.makeDistroSeries(distribution=distro)
-        sp_name = self.factory.getOrMakeSourcePackageName()
-        sp = self.factory.makeSourcePackage(
-            sourcepackagename=sp_name, distroseries=distroseries)
-        owner = self.factory.makePerson()
-        self.factory.makeAccessPolicy(pillar=distro)
-        bug = self.factory.makeBug(
-            target=sp.distribution_sourcepackage, owner=owner,
-            information_type=InformationType.PROPRIETARY)
+            information_type=InformationType.PRIVATESECURITY)
+        # XXX wgrant 2012-08-30 bug=1041002: Distributions don't have
+        # sharing policies yet, so it isn't possible legitimately create
+        # a Proprietary distro bug.
+        removeSecurityProxy(bug).information_type = (
+            InformationType.PROPRIETARY)
         with person_logged_in(owner):
             view = self._createView(bug)
             self.assertFalse(view.canAddProjectTask())
 
=== modified file 'lib/lp/bugs/doc/bug.txt'
--- lib/lp/bugs/doc/bug.txt	2012-08-27 23:58:18 +0000
+++ lib/lp/bugs/doc/bug.txt	2012-08-30 06:21:19 +0000
@@ -654,101 +654,6 @@
     >>> print firefox_bug.default_bugtask.bugtargetdisplayname
     Mozilla Firefox
 
-It's not always possible to add another bug task to a bug.
-Proprietary bugs are only allowed to affect a single project or distribution.
-
-    >>> params = CreateBugParams(
-    ...     title="a test private bug",
-    ...     comment="a description of the bug",
-    ...     owner=current_user())
-    >>> private_bug = firefox.createBug(params)
-    >>> ignored = factory.makeAccessPolicy(pillar=firefox)
-    >>> private_bug.transitionToInformationType(
-    ...     InformationType.PROPRIETARY, current_user())
-    True
-
-    >>> params = CreateBugParams(
-    ...     title="a test public bug",
-    ...     comment="a description of the bug",
-    ...     owner=current_user())
-    >>> public_bug = firefox.createBug(params)
-
-We can always add any new bug task to a public bug.
-
-    >>> tomcat = getUtility(IProductSet).getByName('tomcat')
-    >>> public_bug.addTask(owner=foobar, target=tomcat)
-    <BugTask for bug...
-
-    >>> target = tomcat.getSeries('trunk')
-    >>> public_bug.addTask(owner=foobar, target=target)
-    <BugTask for bug...
-
-If we try and add an invalid bug task to a private bug we get an exception.
-
-    >>> private_bug.addTask(owner=foobar, target=tomcat)
-    Traceback (most recent call last):
-    ...
-    IllegalTarget: This proprietary bug already affects Mozilla Firefox.
-    Proprietary bugs cannot affect multiple projects.
-
-    >>> private_bug.addTask(owner=foobar, target=ubuntu)
-    Traceback (most recent call last):
-    ...
-    IllegalTarget: This proprietary bug already affects Mozilla Firefox.
-    Proprietary bugs cannot affect multiple projects.
-
-We can add a new product series task so long as it's for the same product as
-is already targeted.
-
-    >>> target = firefox.getSeries('1.0')
-    >>> private_bug.addTask(owner=foobar, target=target)
-    <BugTask for bug...
-
-    >>> target = tomcat.getSeries('trunk')
-    >>> private_bug.addTask(owner=foobar, target=target)
-    Traceback (most recent call last):
-    ...
-    IllegalTarget: This proprietary bug already affects Mozilla Firefox.
-    Proprietary bugs cannot affect multiple projects.
-
-Now we create a bug on a distribution.
-
-    >>> private_bug = ubuntu.createBug(params)
-    >>> private_bug.setPrivate(True, current_user())
-    True
-
-We can add a new distro series task so long as it's for the same distro as
-is already targeted.
-
-    >>> private_bug.addTask(owner=foobar, target=warty)
-    <BugTask for bug...
-
-We can also add an allowed distro series source package.
-
-    >>> private_bug.addTask(owner=foobar, target=warty_fox_package)
-    <BugTask for bug...
-
-We cannot add distro series or source package tasks for different distros.
-
-    >>> private_bug = tubuntu.createBug(params)
-    >>> ignored = factory.makeAccessPolicy(pillar=tubuntu)
-    >>> private_bug.transitionToInformationType(
-    ...     InformationType.PROPRIETARY, current_user())
-    True
-
-    >>> private_bug.addTask(owner=foobar, target=warty)
-    Traceback (most recent call last):
-    ...
-    IllegalTarget: This proprietary bug already affects Tubuntu.
-    Proprietary bugs cannot affect multiple projects.
-
-    >>> private_bug.addTask(owner=foobar, target=warty_fox_package)
-    Traceback (most recent call last):
-    ...
-    IllegalTarget: This proprietary bug already affects Tubuntu.
-    Proprietary bugs cannot affect multiple projects.
-
-
 Changing bug visibility.
 
     >>> bug_before_modification = Snapshot(firefox_bug, providing=IBug)
 
=== modified file 'lib/lp/bugs/errors.py'
--- lib/lp/bugs/errors.py	2012-08-08 04:48:40 +0000
+++ lib/lp/bugs/errors.py	2012-08-30 06:21:19 +0000
@@ -5,7 +5,6 @@
 
 __metaclass__ = type
 __all__ = [
-    'BugCannotBePrivate',
     'InvalidDuplicateValue',
 ]
 
@@ -19,8 +18,3 @@
 @error_status(httplib.EXPECTATION_FAILED)
 class InvalidDuplicateValue(LaunchpadValidationError):
     """A bug cannot be set as the duplicate of another."""
-
-
-@error_status(httplib.BAD_REQUEST)
-class BugCannotBePrivate(Exception):
-    """The bug is not allowed to be private."""
 
=== modified file 'lib/lp/bugs/mail/tests/test_commands.py'
--- lib/lp/bugs/mail/tests/test_commands.py	2012-08-27 23:58:18 +0000
+++ lib/lp/bugs/mail/tests/test_commands.py	2012-08-30 06:21:19 +0000
@@ -20,7 +20,10 @@
     TagEmailCommand,
     UnsubscribeEmailCommand,
     )
-from lp.registry.enums import InformationType
+from lp.registry.enums import (
+    BugSharingPolicy,
+    InformationType,
+    )
 from lp.services.mail.interfaces import (
     BugTargetNotFound,
     EmailProcessingError,
@@ -286,11 +289,12 @@
     def test_execute_bug_cannot_add_task(self):
         # Test that attempts to invalidly add a new bug task results in the
         # expected error message.
-        product = self.factory.makeProduct()
-        self.factory.makeAccessPolicy(pillar=product)
+        product = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
         bug = self.factory.makeBug(
             target=product, information_type=InformationType.PROPRIETARY)
-        self.factory.makeProduct(name='fnord')
+        self.factory.makeProduct(
+            name='fnord', bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
         login_celebrity('admin')
         login_person(bug.owner)
         command = AffectsEmailCommand('affects', ['fnord'])
 
=== modified file 'lib/lp/bugs/model/bug.py'
--- lib/lp/bugs/model/bug.py	2012-08-24 05:09:51 +0000
+++ lib/lp/bugs/model/bug.py	2012-08-30 06:21:19 +0000
@@ -100,10 +100,7 @@
     UnsubscribedFromBug,
     )
 from lp.bugs.enums import BugNotificationLevel
-from lp.bugs.errors import (
-    BugCannotBePrivate,
-    InvalidDuplicateValue,
-    )
+from lp.bugs.errors import InvalidDuplicateValue
 from lp.bugs.interfaces.bug import (
     IBug,
     IBugBecameQuestionEvent,
@@ -160,8 +157,10 @@
 from lp.registry.enums import (
     InformationType,
     PRIVATE_INFORMATION_TYPES,
+    PROPRIETARY_INFORMATION_TYPES,
     SECURITY_INFORMATION_TYPES,
     )
+from lp.registry.errors import CannotChangeInformationType
 from lp.registry.interfaces.accesspolicy import (
     IAccessArtifactGrantSource,
     IAccessArtifactSource,
@@ -1710,10 +1709,12 @@
         """See `IBug`."""
         if self.information_type == information_type:
             return False
-        if (information_type == InformationType.PROPRIETARY and
-            len(self.affected_pillars) > 1):
-            raise BugCannotBePrivate(
-                "Multi-pillar bugs cannot be proprietary.")
+        if information_type not in self.getAllowedInformationTypes(who):
+            raise CannotChangeInformationType("Forbidden by project policy.")
+        if (information_type in PROPRIETARY_INFORMATION_TYPES
+            and len(self.affected_pillars) > 1):
+            raise CannotChangeInformationType(
+                "Proprietary bugs can only affect one project.")
         if information_type in PRIVATE_INFORMATION_TYPES:
             self.who_made_private = who
             self.date_made_private = UTC_NOW
 
=== modified file 'lib/lp/bugs/model/bugtask.py'
--- lib/lp/bugs/model/bugtask.py	2012-08-29 06:24:05 +0000
+++ lib/lp/bugs/model/bugtask.py	2012-08-30 06:21:19 +0000
@@ -94,7 +94,7 @@
     )
 from lp.bugs.interfaces.bugtasksearch import BugTaskSearchParams
 from lp.registry.enums import (
-    InformationType,
+    PROPRIETARY_INFORMATION_TYPES,
     PUBLIC_INFORMATION_TYPES,
     )
 from lp.registry.interfaces.distribution import (
@@ -337,7 +337,13 @@
             except NotFoundError as e:
                 raise IllegalTarget(e[0])
 
-    if bug.information_type == InformationType.PROPRIETARY:
+    legal_types = target.pillar.getAllowedBugInformationTypes()
+    if bug.information_type not in legal_types:
+        raise IllegalTarget(
+            "%s doesn't allow %s bugs." % (
+            target.pillar.bugtargetdisplayname, bug.information_type.title))
+
+    if bug.information_type in PROPRIETARY_INFORMATION_TYPES:
         # Perhaps we are replacing the one and only existing bugtask, in
         # which case that's ok.
         if retarget_existing and len(bug.bugtasks) <= 1:
@@ -348,7 +354,7 @@
             raise IllegalTarget(
                 "This proprietary bug already affects %s. "
                 "Proprietary bugs cannot affect multiple projects."
-                    % bug.default_bugtask.target.bugtargetdisplayname)
+                    % bug.default_bugtask.target.pillar.bugtargetdisplayname)
 
 
 def validate_new_target(bug, target):
 
=== modified file 'lib/lp/bugs/model/tests/test_bug.py'
--- lib/lp/bugs/model/tests/test_bug.py	2012-08-28 01:35:08 +0000
+++ lib/lp/bugs/model/tests/test_bug.py	2012-08-30 06:21:19 +0000
@@ -20,7 +20,6 @@
     BugNotificationLevel,
     BugNotificationStatus,
     )
-from lp.bugs.errors import BugCannotBePrivate
 from lp.bugs.interfaces.bugnotification import IBugNotificationSet
 from lp.bugs.interfaces.bugtask import BugTaskStatus
 from lp.bugs.mail.bugnotificationrecipients import BugNotificationRecipients
@@ -28,7 +27,11 @@
     BugNotification,
     BugSubscriptionInfo,
     )
-from lp.registry.enums import InformationType
+from lp.registry.enums import (
+    BugSharingPolicy,
+    InformationType,
+    )
+from lp.registry.errors import CannotChangeInformationType
 from lp.registry.interfaces.accesspolicy import (
     IAccessArtifactSource,
     IAccessPolicyArtifactSource,
@@ -753,12 +756,17 @@
 
     def test_multipillar_proprietary_bugs_disallowed(self):
         # A multi-pillar bug cannot be made proprietary.
-        bug = self.factory.makeBug()
-        product = self.factory.makeProduct()
-        self.factory.makeBugTask(bug=bug, target=product)
+        p1 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PUBLIC_OR_PROPRIETARY)
+        p2 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PUBLIC_OR_PROPRIETARY)
+        bug = self.factory.makeBug(target=p1)
+        self.factory.makeBugTask(bug=bug, target=p2)
         login_person(bug.owner)
-        self.assertRaises(
-            BugCannotBePrivate, bug.transitionToInformationType,
+        self.assertRaisesWithContent(
+            CannotChangeInformationType,
+            "Proprietary bugs can only affect one project.",
+            bug.transitionToInformationType,
             InformationType.PROPRIETARY, bug.owner)
         bug.transitionToInformationType(InformationType.USERDATA, bug.owner)
         self.assertTrue(bug.private)
@@ -869,6 +877,29 @@
              InformationType.PRIVATESECURITY, InformationType.USERDATA],
             self.factory.makeBug().getAllowedInformationTypes(None))
 
+    def test_transitionToInformationType_respects_allowed_proprietary(self):
+        # transitionToInformationType rejects types that aren't allowed
+        # for the bug.
+        product = self.factory.makeProduct()
+        with person_logged_in(product.owner):
+            bug = self.factory.makeBug(target=product)
+            self.assertRaisesWithContent(
+                CannotChangeInformationType, "Forbidden by project policy.",
+                bug.transitionToInformationType,
+                InformationType.PROPRIETARY, bug.owner)
+
+    def test_transitionToInformationType_respects_allowed_public(self):
+        # transitionToInformationType rejects types that aren't allowed
+        # for the bug.
+        product = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
+        with person_logged_in(product.owner):
+            bug = self.factory.makeBug(target=product)
+            self.assertRaisesWithContent(
+                CannotChangeInformationType, "Forbidden by project policy.",
+                bug.transitionToInformationType,
+                InformationType.PUBLIC, bug.owner)
+
 
 class TestBugPrivateAndSecurityRelatedUpdatesPrivateProject(
         TestBugPrivateAndSecurityRelatedUpdatesMixin, TestCaseWithFactory):
 
=== modified file 'lib/lp/bugs/model/tests/test_bugtask.py'
--- lib/lp/bugs/model/tests/test_bugtask.py	2012-08-29 06:24:05 +0000
+++ lib/lp/bugs/model/tests/test_bugtask.py	2012-08-30 06:21:19 +0000
@@ -56,6 +56,7 @@
     )
 from lp.bugs.tests.bug import create_old_bug
 from lp.registry.enums import (
+    BugSharingPolicy,
     InformationType,
     TeamMembershipPolicy,
     )
@@ -2847,52 +2848,26 @@
         a private bugs to check for multi-tenant constraints.
     """
 
-    def test_private_multi_tenanted_forbidden(self):
-        # A new task project cannot be added if there is already one from
-        # another pillar.
-        d = self.factory.makeDistribution()
-        bug = self.factory.makeBug(target=d)
-        if not self.multi_tenant_test_one_task_only:
-            self.factory.makeBugTask(bug=bug)
-        p = self.factory.makeProduct()
-        self.factory.makeAccessPolicy(pillar=d)
-        with person_logged_in(bug.owner):
-            bug.transitionToInformationType(
-                InformationType.PROPRIETARY, bug.owner)
-            self.assertRaisesWithContent(
-                IllegalTarget,
-                "This proprietary bug already affects %s. "
-                "Proprietary bugs cannot affect multiple projects."
-                    % d.displayname,
-                self.validate_method, bug, p)
-            bug.transitionToInformationType(
-                InformationType.USERDATA, bug.owner)
-            self.validate_method(bug, p)
-
     def test_private_incorrect_pillar_task_forbidden(self):
-        # A product or distro cannot be added if there is already a bugtask.
-        p1 = self.factory.makeProduct()
-        p2 = self.factory.makeProduct()
-        d = self.factory.makeDistribution()
-        bug = self.factory.makeBug(target=p1)
+        # Another pillar cannot be added if there is already a bugtask.
+        p1 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY_OR_PUBLIC)
+        p2 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY_OR_PUBLIC)
+        owner = self.factory.makePerson()
+        bug = self.factory.makeBug(target=p1, owner=owner)
+        # validate_target allows cross-pillar transitions if there's
+        # only one task, so we might need to create a second task to test.
         if not self.multi_tenant_test_one_task_only:
-            self.factory.makeBugTask(bug=bug)
-        self.factory.makeAccessPolicy(pillar=p1)
-        with person_logged_in(bug.owner):
-            bug.transitionToInformationType(
-                InformationType.PROPRIETARY, bug.owner)
+            self.factory.makeBugTask(
+                bug=bug, target=self.factory.makeProductSeries(product=p1))
+        with person_logged_in(owner):
             self.assertRaisesWithContent(
                 IllegalTarget,
                 "This proprietary bug already affects %s. "
                 "Proprietary bugs cannot affect multiple projects."
                     % p1.displayname,
                 self.validate_method, bug, p2)
-            self.assertRaisesWithContent(
-                IllegalTarget,
-                "This proprietary bug already affects %s. "
-                "Proprietary bugs cannot affect multiple projects."
-                    % p1.displayname,
-                self.validate_method, bug, d)
             bug.transitionToInformationType(
                 InformationType.USERDATA, bug.owner)
             self.validate_method(bug, p2)
@@ -2900,16 +2875,19 @@
     def test_private_incorrect_product_series_task_forbidden(self):
         # A product series cannot be added if there is already a bugtask for
         # a different product.
-        p1 = self.factory.makeProduct()
-        p2 = self.factory.makeProduct()
+        p1 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY_OR_PUBLIC)
+        p2 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY_OR_PUBLIC)
         series = self.factory.makeProductSeries(product=p2)
-        bug = self.factory.makeBug(target=p1)
+        owner = self.factory.makePerson()
+        bug = self.factory.makeBug(target=p1, owner=owner)
+        # validate_target allows cross-pillar transitions if there's
+        # only one task, so we might need to create a second task to test.
         if not self.multi_tenant_test_one_task_only:
-            self.factory.makeBugTask(bug=bug)
-        self.factory.makeAccessPolicy(pillar=p1)
-        with person_logged_in(bug.owner):
-            bug.transitionToInformationType(
-                InformationType.PROPRIETARY, bug.owner)
+            self.factory.makeBugTask(
+                bug=bug, target=self.factory.makeProductSeries(product=p1))
+        with person_logged_in(owner):
             self.assertRaisesWithContent(
                 IllegalTarget,
                 "This proprietary bug already affects %s. "
@@ -2920,29 +2898,6 @@
                 InformationType.USERDATA, bug.owner)
             self.validate_method(bug, series)
 
-    def test_private_incorrect_distro_series_task_forbidden(self):
-        # A distro series cannot be added if there is already a bugtask for
-        # a different distro.
-        d1 = self.factory.makeDistribution()
-        d2 = self.factory.makeDistribution()
-        series = self.factory.makeDistroSeries(distribution=d2)
-        bug = self.factory.makeBug(target=d1)
-        if not self.multi_tenant_test_one_task_only:
-            self.factory.makeBugTask(bug=bug)
-        self.factory.makeAccessPolicy(pillar=d1)
-        with person_logged_in(bug.owner):
-            bug.transitionToInformationType(
-                InformationType.PROPRIETARY, bug.owner)
-            self.assertRaisesWithContent(
-                IllegalTarget,
-                "This proprietary bug already affects %s. "
-                "Proprietary bugs cannot affect multiple projects."
-                    % d1.displayname,
-                self.validate_method, bug, series)
-            bug.transitionToInformationType(
-                InformationType.USERDATA, bug.owner)
-            self.validate_method(bug, series)
-
 
 class TestValidateTarget(TestCaseWithFactory, ValidateTargetMixin):
 
@@ -3082,6 +3037,24 @@
             % (dsp.sourcepackagename.name, dsp.distribution.displayname),
             validate_target, task.bug, dsp)
 
+    def test_illegal_information_type_disallowed(self):
+        # The bug's current information_type must be permitted by the
+        # new target.
+        free_prod = self.factory.makeProduct()
+        other_free_prod = self.factory.makeProduct()
+        commercial_prod = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
+        bug = self.factory.makeBug(target=free_prod)
+
+        # The new bug is Public, which is legal on the other free product.
+        self.assertIs(None, validate_target(bug, other_free_prod))
+
+        # But not on the proprietary-only product.
+        self.assertRaisesWithContent(
+            IllegalTarget,
+            "%s doesn't allow Public bugs." % commercial_prod.displayname,
+            validate_target, bug, commercial_prod)
+
 
 class TestValidateNewTarget(TestCaseWithFactory, ValidateTargetMixin):
 
 
=== modified file 'lib/lp/bugs/stories/bug-also-affects/xx-bug-also-affects.txt'
--- lib/lp/bugs/stories/bug-also-affects/xx-bug-also-affects.txt	2012-08-27 23:58:18 +0000
+++ lib/lp/bugs/stories/bug-also-affects/xx-bug-also-affects.txt	2012-08-30 06:21:19 +0000
@@ -201,41 +201,41 @@
     ...>pmount (Debian)</a>...
     ...
 
-We cannot allow private bugs to affect more than one pillar.
+We cannot allow proprietary bugs to affect more than one pillar.
 
     >>> from lp.services.webapp import canonical_url
     >>> from lp.services.webapp.interfaces import ILaunchBag
     >>> from lp.bugs.interfaces.bug import CreateBugParams
-    >>> from lp.registry.interfaces.product import IProductSet
-    >>> from lp.registry.enums import InformationType
+    >>> from lp.registry.enums import BugSharingPolicy, InformationType
 
     >>> def current_user():
     ...     return getUtility(ILaunchBag).user
 
-    >>> login("[e-mail]")
-    >>> productset = getUtility(IProductSet)
-    >>> firefox = productset.get(4)
-    >>> ignored = factory.makeAccessPolicy(pillar=firefox)
+    >>> login("[e-mail]")
+    >>> product = factory.makeProduct(
+    ...     displayname='Proprietary Product', name='proprietary-product',
+    ...     bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
+    >>> other_product = factory.makeProduct(
+    ...     official_malone=True,
+    ...     bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
     >>> params = CreateBugParams(
     ...     title="a test private bug",
     ...     comment="a description of the bug",
     ...     information_type=InformationType.PROPRIETARY,
     ...     owner=current_user())
-    >>> private_bug = firefox.createBug(params)
-    >>> private_bug.subscribe(firefox.owner, firefox.owner)
-    <lp.bugs.model.bugsubscription.BugSubscription object at ...>
+    >>> private_bug = product.createBug(params)
     >>> logout()
 
     >>> browser.open(canonical_url(private_bug, rootsite='bugs'))
-    >>> browser.getLink(url='+distrotask').click()
-    >>> browser.getControl(name='field.distribution').value = ['debian']
+    >>> browser.getLink(url='+choose-affected-product').click()
+    >>> browser.getControl(name='field.product').value = other_product.name
     >>> browser.getControl('Continue').click()
     >>> print browser.url
-    http://bugs.launchpad.dev/firefox/+bug/16/+distrotask
+    http://bugs.launchpad.dev/proprietary-product/+bug/16/+choose-affected-product
 
     >>> print get_feedback_messages(browser.contents)
     [u'There is 1 error.',
-     u'This proprietary bug already affects Mozilla Firefox.
+     u'This proprietary bug already affects Proprietary Product.
        Proprietary bugs cannot affect multiple projects.']
 
 
 
=== modified file 'lib/lp/bugs/tests/test_bugs_webservice.py'
--- lib/lp/bugs/tests/test_bugs_webservice.py	2012-08-29 06:57:53 +0000
+++ lib/lp/bugs/tests/test_bugs_webservice.py	2012-08-30 06:21:19 +0000
@@ -361,15 +361,19 @@
         # a proprietary bug. In this case, we cannot mark a proprietary bug
         # as affecting more than one project.
         owner = self.factory.makePerson()
+        product1 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
+        product2 = self.factory.makeProduct(
+            bug_sharing_policy=BugSharingPolicy.PROPRIETARY)
         bug = self.factory.makeBug(
-            owner=owner, information_type=InformationType.PROPRIETARY)
-        product = self.factory.makeProduct()
+            target=product1, owner=owner,
+            information_type=InformationType.PROPRIETARY)
 
         login_person(owner)
         launchpad = launchpadlib_for('test', owner)
         lp_bug = launchpad.load(api_url(bug))
         self.assertRaises(
-            BadRequest, lp_bug.addTask, target=api_url(product))
+            BadRequest, lp_bug.addTask, target=api_url(product2))
 
 
 class BugSetTestCase(TestCaseWithFactory):
 
=== modified file 'lib/lp/code/errors.py'
--- lib/lp/code/errors.py	2012-07-11 09:36:13 +0000
+++ lib/lp/code/errors.py	2012-08-30 06:21:19 +0000
@@ -8,7 +8,6 @@
     'AlreadyLatestFormat',
     'BadBranchMergeProposalSearchContext',
     'BadStateTransition',
-    'BranchCannotChangeInformationType',
     'BranchCreationException',
     'BranchCreationForbidden',
     'BranchCreatorNotMemberOfOwnerTeam',
@@ -146,10 +145,6 @@
     """
 
 
-class BranchCannotChangeInformationType(Exception):
-    """The information type of this branch cannot be changed."""
-
-
 class InvalidBranchException(Exception):
     """Base exception for an error resolving a branch for a component.
 
 
=== modified file 'lib/lp/code/model/branch.py'
--- lib/lp/code/model/branch.py	2012-08-29 02:40:36 +0000
+++ lib/lp/code/model/branch.py	2012-08-30 06:21:19 +0000
@@ -80,7 +80,6 @@
     )
 from lp.code.errors import (
     AlreadyLatestFormat,
-    BranchCannotChangeInformationType,
     BranchMergeProposalExists,
     BranchTargetError,
     BranchTypeError,
@@ -137,6 +136,7 @@
     PRIVATE_INFORMATION_TYPES,
     PUBLIC_INFORMATION_TYPES,
     )
+from lp.registry.errors import CannotChangeInformationType
 from lp.registry.interfaces.accesspolicy import (
     IAccessArtifactGrantSource,
     IAccessArtifactSource,
@@ -249,10 +249,10 @@
         if (self.stacked_on
             and self.stacked_on.information_type in PRIVATE_INFORMATION_TYPES
             and information_type in PUBLIC_INFORMATION_TYPES):
-            raise BranchCannotChangeInformationType()
+            raise CannotChangeInformationType("Must match stacked-on branch.")
         if (verify_policy
             and information_type not in self.getAllowedInformationTypes(who)):
-            raise BranchCannotChangeInformationType()
+            raise CannotChangeInformationType("Forbidden by project policy.")
         self.information_type = information_type
         self._reconcileAccess()
         if information_type in PRIVATE_INFORMATION_TYPES and self.subscribers:
 
=== modified file 'lib/lp/code/model/tests/test_branch.py'
--- lib/lp/code/model/tests/test_branch.py	2012-08-29 03:19:38 +0000
+++ lib/lp/code/model/tests/test_branch.py	2012-08-30 06:21:19 +0000
@@ -54,7 +54,6 @@
     )
 from lp.code.errors import (
     AlreadyLatestFormat,
-    BranchCannotChangeInformationType,
     BranchCreatorNotMemberOfOwnerTeam,
     BranchCreatorNotOwner,
     BranchTargetError,
@@ -120,6 +119,7 @@
     PUBLIC_INFORMATION_TYPES,
     TeamMembershipPolicy,
     )
+from lp.registry.errors import CannotChangeInformationType
 from lp.registry.interfaces.accesspolicy import (
     IAccessArtifactSource,
     IAccessPolicyArtifactSource,
@@ -2480,13 +2480,12 @@
 
     def test_public_to_private_not_allowed(self):
         # If there are no privacy policies allowing private branches, then
-        # BranchCannotChangeInformationType is rasied.
+        # CannotChangeInformationType is raised.
         product = self.factory.makeLegacyProduct()
         branch = self.factory.makeBranch(product=product)
-        self.assertRaises(
-            BranchCannotChangeInformationType,
-            branch.setPrivate,
-            True, branch.owner)
+        self.assertRaisesWithContent(
+            CannotChangeInformationType, 'Forbidden by project policy.',
+            branch.setPrivate, True, branch.owner)
 
     def test_public_to_private_for_admins(self):
         # Admins can override the default behaviour and make any public branch
@@ -2522,8 +2521,7 @@
 
     def test_private_to_public_not_allowed(self):
         # If the namespace policy does not allow public branches, attempting
-        # to change the branch to be public raises
-        # BranchCannotChangeInformationType.
+        # to change the branch to be public raises CannotChangeInformationType.
         product = self.factory.makeLegacyProduct()
         branch = self.factory.makeBranch(
             product=product,
@@ -2532,10 +2530,9 @@
             None, BranchVisibilityRule.FORBIDDEN)
         branch.product.setBranchVisibilityTeamPolicy(
             branch.owner, BranchVisibilityRule.PRIVATE_ONLY)
-        self.assertRaises(
-            BranchCannotChangeInformationType,
-            branch.setPrivate,
-            False, branch.owner)
+        self.assertRaisesWithContent(
+            CannotChangeInformationType, 'Forbidden by project policy.',
+            branch.setPrivate, False, branch.owner)
 
     def test_cannot_transition_with_private_stacked_on(self):
         # If a public branch is stacked on a private branch, it can not
@@ -2543,8 +2540,8 @@
         stacked_on = self.factory.makeBranch(
             information_type=InformationType.USERDATA)
         branch = self.factory.makeBranch(stacked_on=stacked_on)
-        self.assertRaises(
-            BranchCannotChangeInformationType,
+        self.assertRaisesWithContent(
+            CannotChangeInformationType, 'Must match stacked-on branch.',
             branch.transitionToInformationType, InformationType.PUBLIC,
             branch.owner)
 
 
=== modified file 'lib/lp/registry/enums.py'
--- lib/lp/registry/enums.py	2012-08-20 13:26:21 +0000
+++ lib/lp/registry/enums.py	2012-08-30 06:21:19 +0000
@@ -18,6 +18,7 @@
     'PersonTransferJobType',
     'PersonVisibility',
     'PRIVATE_INFORMATION_TYPES',
+    'PROPRIETARY_INFORMATION_TYPES',
     'PUBLIC_INFORMATION_TYPES',
     'ProductJobType',
     'SECURITY_INFORMATION_TYPES',
@@ -97,6 +98,9 @@
 FREE_INFORMATION_TYPES = (
     PUBLIC_INFORMATION_TYPES + FREE_PRIVATE_INFORMATION_TYPES)
 
+PROPRIETARY_INFORMATION_TYPES = (
+    InformationType.PROPRIETARY, InformationType.EMBARGOED)
+
 
 class SharingPermission(DBEnumeratedType):
     """Sharing permission.
 
=== modified file 'lib/lp/registry/errors.py'
--- lib/lp/registry/errors.py	2012-08-13 20:17:56 +0000
+++ lib/lp/registry/errors.py	2012-08-30 06:21:19 +0000
@@ -5,6 +5,7 @@
 __all__ = [
     'DistroSeriesDifferenceError',
     'NotADerivedSeriesError',
+    'CannotChangeInformationType',
     'CannotDeleteCommercialSubscription',
     'CannotTransitionToCountryMirror',
     'CommercialSubscribersOnly',
@@ -190,3 +191,8 @@
 
 class CannotDeleteCommercialSubscription(Exception):
     """Raised when a commercial subscription cannot be deleted."""
+
+
+@error_status(httplib.BAD_REQUEST)
+class CannotChangeInformationType(Exception):
+    """The information type cannot be changed."""