Merge lp:~stevenk/launchpad/information_type-vocab into lp:launchpad

[Steve Kowalik]

Add a vocabulary for the InformationType enum, which allows us to change what is displayed via feature flags.

Add a vocabulary for the InformationType enum. I have added two feature flags, one that changes User Data to display as Private, and the other that hides Proprietary. I have pulled in some code into BugView which is tested, but not used yet to make later branches a little smaller.

This branch isn't testable on it's own, it is just setting up plumbing for the upcoming UI branches.

[William Grant (wgrant)]

25 + cache.objects['information_types'] = [
26 + {'value': term.value, 'description': term.description,
27 + 'name': term.title} for term in InformationTypeVocabulary()]

This seems like a common pattern. Is there a helper? If not, might it be an idea to add one?

28 + cache.objects['private_types'] = [
29 + type.value for type in PRIVATE_INFORMATION_TYPES]

type.value is the integer. Enums are not represented by integers, except at the database layer.

30 + cache.objects['initial_information_type'] = (
31 + IBug(self.context).information_type.value)

Likewise. But isn't this already in LP.cache.context?

40 + @property
41 + def information_type(self):

I'd like a comment stating that this whole mess can be replaced with bug.information_type.title once we switch to showing User Data.

83 + def test_information_type_feature_flag(self):

This could do with a comment and a better name.

115 + def test_getTermByToken(self):
116 + vocab = InformationTypeVocabulary()
117 + term = vocab.getTermByToken('PUBLIC')
118 + self.assertEqual(InformationType.PUBLIC, term.value)
119 + self.assertEqual('PUBLIC', term.token)
120 + self.assertEqual('Public', term.title)
121 + self.assertEqual(
122 + InformationType.PUBLIC.description, term.description)

Do you know about MatchesStructure?

214 + term = SimpleTerm(type, type.name, title)
215 + term.description = description

Does the constructor seriously not take description?

review: Approve (code)

=== modified file 'lib/lp/bugs/browser/bug.py'
--- lib/lp/bugs/browser/bug.py	2012-04-03 06:14:09 +0000
+++ lib/lp/bugs/browser/bug.py	2012-04-11 11:58:19 +0000
@@ -95,7 +95,12 @@
 from lp.bugs.model.structuralsubscription import (
     get_structural_subscriptions_for_bug,
     )
-from lp.registry.enums import InformationType
+from lp.registry.enums import (
+    InformationType,
+    PRIVATE_INFORMATION_TYPES,
+    )
+from lp.registry.vocabularies import InformationTypeVocabulary
+from lp.services.features import getFeatureFlag
 from lp.services.fields import DuplicateBug
 from lp.services.librarian.browser import ProxiedLibraryFileAlias
 from lp.services.mail.mailwrapper import MailWrapper
@@ -548,6 +553,15 @@
     all the pages off IBugTask instead of IBug.
     """
 
+    def initialize(self):
+        super(BugView, self).initialize()
+        cache = IJSONRequestCache(self.request)
+        cache.objects['information_types'] = [
+            {'value': term.value, 'description': term.description,
+            'name': term.title} for term in InformationTypeVocabulary()]
+        cache.objects['private_types'] = [
+            type.name for type in PRIVATE_INFORMATION_TYPES]
+
     @cachedproperty
     def page_description(self):
         return IBug(self.context).description
@@ -596,6 +610,18 @@
         return ProxiedLibraryFileAlias(
             attachment.libraryfile, attachment).http_url
 
+    @property
+    def information_type(self):
+        # This can be replaced with just a return when the feature flag is
+        # dropped.
+        title = self.context.information_type.title
+        show_userdata_as_private = bool(getFeatureFlag(
+            'disclosure.display_userdata_as_private.enabled'))
+        if (
+            self.context.information_type == InformationType.USERDATA and
+            show_userdata_as_private):
+            return 'Private'
+        return title
 
 class BugActivity(BugView):
 

=== modified file 'lib/lp/bugs/browser/tests/test_bugview.py'
--- lib/lp/bugs/browser/tests/test_bugview.py	2012-01-01 02:58:52 +0000
+++ lib/lp/bugs/browser/tests/test_bugview.py	2012-04-11 11:58:19 +0000
@@ -1,4 +1,4 @@
-# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2012 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __metaclass__ = type
@@ -6,6 +6,8 @@
 from zope.security.proxy import removeSecurityProxy
 
 from lp.bugs.browser.bug import BugView
+from lp.registry.enums import InformationType
+from lp.services.features.testing import FeatureFixture
 from lp.services.webapp.servers import LaunchpadTestRequest
 from lp.testing import (
     login,
@@ -54,3 +56,20 @@
             ['patch'],
             [attachment['attachment'].title
              for attachment in self.view.patches])
+
+    def test_information_type(self):
+        self.bug.transitionToInformationType(
+            InformationType.USERDATA, self.bug.owner)
+        self.assertEqual(
+            self.bug.information_type.title, self.view.information_type)
+        
+    def test_userdata_shown_as_private(self):
+        # When the display_userdata_as_private feature flag is enabled, the
+        # information_type is shown as 'Private'.
+        self.bug.transitionToInformationType(
+            InformationType.USERDATA, self.bug.owner)
+        feature_flag = {
+            'disclosure.display_userdata_as_private.enabled': 'on'}
+        with FeatureFixture(feature_flag):
+            view = BugView(self.bug, LaunchpadTestRequest())
+            self.assertEqual('Private', view.information_type)

=== added file 'lib/lp/registry/tests/test_information_type_vocabulary.py'
--- lib/lp/registry/tests/test_information_type_vocabulary.py	1970-01-01 00:00:00 +0000
+++ lib/lp/registry/tests/test_information_type_vocabulary.py	2012-04-11 11:58:19 +0000
@@ -0,0 +1,65 @@
+# Copyright 2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test the Distribution Source Package vocabulary."""
+
+__metaclass__ = type
+
+
+from testtools.matchers import MatchesStructure
+
+from lp.registry.enums import InformationType
+from lp.registry.vocabularies import InformationTypeVocabulary
+from lp.services.features.testing import FeatureFixture
+from lp.testing import TestCase
+from lp.testing.layers import DatabaseFunctionalLayer
+
+
+class TestInformationTypeVocabulary(TestCase):
+
+    layer = DatabaseFunctionalLayer
+
+    def test_getTermByToken(self):
+        vocab = InformationTypeVocabulary()
+        self.assertThat(
+            vocab.getTermByToken('PUBLIC'),
+            MatchesStructure.byEquality(
+                value=InformationType.PUBLIC,
+                token='PUBLIC',
+                title='Public',
+                description=InformationType.PUBLIC.description))
+
+    def test_proprietary_disabled(self):
+        feature_flag = {
+            'disclosure.proprietary_information_type.disabled': 'on'}
+        with FeatureFixture(feature_flag):
+            vocab = InformationTypeVocabulary()
+            self.assertRaises(
+                LookupError, vocab.getTermByToken, 'PROPRIETARY')
+
+    def test_proprietary_enabled(self):
+        vocab = InformationTypeVocabulary()
+        term = vocab.getTermByToken('PROPRIETARY')
+        self.assertEqual('Proprietary', term.title)
+
+    def test_display_userdata_as_private(self):
+        feature_flag = {
+            'disclosure.display_userdata_as_private.enabled': 'on'}
+        with FeatureFixture(feature_flag):
+            vocab = InformationTypeVocabulary()
+            term = vocab.getTermByToken('USERDATA')
+            self.assertEqual('Private', term.title)
+            self.assertEqual(
+                "Only users with permission to see the project's artifacts "
+                "containing\nprivate information can see this "
+                "information.\n",
+                term.description)
+
+    def test_userdata(self):
+        vocab = InformationTypeVocabulary()
+        term = vocab.getTermByToken('USERDATA')
+        self.assertEqual('User Data', term.title)
+        self.assertEqual(
+            "Only users with permission to see the project's artifacts "
+            "containing\nuser data can see this information.\n",
+            term.description)

=== modified file 'lib/lp/registry/vocabularies.py'
--- lib/lp/registry/vocabularies.py	2012-03-27 21:34:58 +0000
+++ lib/lp/registry/vocabularies.py	2012-04-11 11:58:19 +0000
@@ -39,6 +39,7 @@
     'FeaturedProjectVocabulary',
     'FilteredDistroSeriesVocabulary',
     'FilteredProductSeriesVocabulary',
+    'InformationTypeVocabulary',
     'KarmaCategoryVocabulary',
     'MilestoneVocabulary',
     'NewPillarShareeVocabulary',
@@ -102,6 +103,7 @@
 from lp.app.interfaces.launchpad import ILaunchpadCelebrities
 from lp.blueprints.interfaces.specification import ISpecification
 from lp.bugs.interfaces.bugtask import IBugTask
+from lp.registry.enums import InformationType
 from lp.registry.interfaces.accesspolicy import IAccessPolicySource
 from lp.registry.interfaces.distribution import (
     IDistribution,
@@ -172,6 +174,7 @@
     SQLBase,
     sqlvalues,
     )
+from lp.services.features import getFeatureFlag
 from lp.services.helpers import (
     ensure_unicode,
     shortlist,
@@ -2220,3 +2223,31 @@
             SQL('DistributionSourcePackage.id = SearchableDSP.id'))
 
         return CountableIterator(dsps.count(), dsps, self.toTerm)
+
+
+class InformationTypeVocabulary(SimpleVocabulary):
+
+    def __init__(self):
+        types = [
+            InformationType.PUBLIC,
+            InformationType.UNEMBARGOEDSECURITY,
+            InformationType.EMBARGOEDSECURITY,
+            InformationType.USERDATA]
+        proprietary_disabled = bool(getFeatureFlag(
+            'disclosure.proprietary_information_type.disabled'))
+        show_userdata_as_private = bool(getFeatureFlag(
+            'disclosure.display_userdata_as_private.enabled'))
+        if not proprietary_disabled:
+            types.append(InformationType.PROPRIETARY)
+        terms = []
+        for type in types:
+            title = type.title
+            description = type.description
+            if type == InformationType.USERDATA and show_userdata_as_private:
+                title = 'Private'
+                description = (
+                    description.replace('user data', 'private information'))
+            term = SimpleTerm(type, type.name, title)
+            term.description = description
+            terms.append(term)
+        super(InformationTypeVocabulary, self).__init__(terms)

=== modified file 'lib/lp/registry/vocabularies.zcml'
--- lib/lp/registry/vocabularies.zcml	2012-03-27 04:06:21 +0000
+++ lib/lp/registry/vocabularies.zcml	2012-04-11 11:58:19 +0000
@@ -1,4 +1,4 @@
-<!-- Copyright 2009 Canonical Ltd.  This software is licensed under the
+<!-- Copyright 2009-2012 Canonical Ltd.  This software is licensed under the
      GNU Affero General Public License version 3 (see the file LICENSE).
 -->
 
@@ -536,4 +536,10 @@
             permission="zope.Public"
             attributes="name title description"/>
     </class>
+    <class
+        class="lp.registry.vocabularies.InformationTypeVocabulary">
+        <require
+            permission="zope.Public"
+            attributes="name title description"/>
+    </class>
 </configure>

=== modified file 'lib/lp/services/features/flags.py'
--- lib/lp/services/features/flags.py	2012-04-09 14:17:07 +0000
+++ lib/lp/services/features/flags.py	2012-04-11 11:58:19 +0000
@@ -321,6 +321,18 @@
      '',
      '',
      ''),
+    ('disclosure.proprietary_information_type.disabled',
+     'boolean',
+     'If true, disables the PROPRIETARY information_type for bugs.',
+     '',
+     '',
+     ''),
+    ('disclosure.display_userdata_as_private.enabled',
+     'boolean',
+     'If true, displays the USERDATA information_type as Private.',
+     '',
+     '',
+     ''),
     ])
 
 # The set of all flag names that are documented.