Merge lp:~sinzui/launchpad/entitlement-2 into lp:launchpad

[Curtis Hovey]

Move license email rules from the view to the model.

We want to give proprietary projects complimentary commercial subscriptions
to ensure that projects can be configured setup to no disclose information
from the start.

This branch follows moves the code that send emails to users about
licenses from the view to the model so that changes made over the API
generate emails. Most of this branch is a refactoring.

--------------------------------------------------------------------

RULES

    PREVIOUS BRANCH
    * When a OTHER/PROPRIETARY license is added to a project, and the
      project does not have any commercial subscriptions add a commercial
      subscription that expires in 4 weeks.
      * We check for previous active and expired commercial subscriptions
        to ensure that users cannot get extra time by reconfiguring their
        project.
        * Product._setLicenses()
      * Use StevenK's example from the LaunchpadFactory to create a
        commercial subscription without a voucher.

    THIS BRANCH
    * Push the rules to send licensing emails to the model.
      * Emails are currently sent by the views that allow users to change
        licenses. Change made in the model or via the API are missin emails.
      * Notify of the ObjectModifiedEvent in the _setLicenses() method.

    FUTURE BRANCH
    * The UI and an email is sent to inform the user of the complimentary
      commercial subscription and it will explain when it expires and how
      to active the proprietary features. There is a link to purchase a
      full subscription.
      * This email probably replaces the existing email that explain Lp's
        licensing and purchasing rules.
    * At 4 weeks and 1 weeks before a commercial subscription expires, a
      reminder is sent to purchase a commercial subscription.
      * the email also explain that the project will be deactivated if the
        subscription is not renewed and the project is still proprietary
        to ensure proprietary is not added added.
      * Users can choose an Open source license. Branches and bugs will
        remain proprietary because we understand that confidential information
        can never be disclosed, but new bugs and branches will be public...
        the project's focus of development must be set to a public branch.
    * Bonus points if there is a clear way to identify a Canonical owned
      project and set the commercial subscription to expire in 10 years.

QA

    * Visit https://qastaging.launchpad.net/projects/+new and create a
      non-proprietary project.
    * Verify an email was not sent.
    * Use Change details to set the license to proprietary.
    * Verify an email was sent to the maintainer explaining Lp's licensing
      policy

    * Visit https://qastaging.launchpad.net/projects/+new and create a
      proprietary project.
    * Verify it has a commercial subscription that expires in one month.
    * Verify an email was sent to the maintainer explaining Lp's licensing
      policy

LINT

    lib/lp/registry/configure.zcml
    lib/lp/registry/subscribers.py
    lib/lp/registry/browser/product.py
    lib/lp/registry/browser/tests/test_product.py
    lib/lp/registry/model/product.py
    lib/lp/registry/tests/test_product.py
    lib/lp/registry/tests/test_subscribers.py
    lib/lp/testing/factory.py

TEST

    ./bin/test -vv lp.registry.tests.browser.test_product
    ./bin/test -vv lp.registry.tests.test_product
    ./bin/test -vv lp.registry.tests.test_subscribers

IMPLEMENTATION

Login as the product owner before creating the product so that there is an
interaction for events to use.
    lib/lp/testing/factory.py

Remove view code and tests -- moved to subscribers.py and
test_subscribers.py. The call to send an email when there were no
licenses is not needed anymore. It will never run in production because
we fixed all the production data. All products have one or more Licenses.
    lib/lp/registry/browser/product.py
    lib/lp/registry/browser/tests/test_product.py

Notify that the licenses changed.
    lib/lp/registry/model/product.py
    lib/lp/registry/tests/test_product.py

Refactored the view code and tests to work with events at the model
level. Removed a dead method called product_modified that was in
subscribers.py, I suspect it is vestigial to product._owner change event
that once needlessly changed the owner of subordinate objects.
    lib/lp/registry/configure.zcml
    lib/lp/registry/subscribers.py
    lib/lp/registry/tests/test_subscribers.py

=== modified file 'lib/lp/registry/browser/product.py'
--- lib/lp/registry/browser/product.py	2012-03-08 17:08:56 +0000
+++ lib/lp/registry/browser/product.py	2012-03-12 18:17:24 +0000
@@ -77,7 +77,6 @@
     SimpleTerm,
     SimpleVocabulary,
     )
-from zope.security.proxy import removeSecurityProxy
 
 from lp import _
 from lp.answers.browser.faqtarget import FAQTargetNavigationMixin
@@ -177,11 +176,6 @@
     PublicPersonChoice,
     )
 from lp.services.librarian.interfaces import ILibraryFileAliasSet
-from lp.services.mail.helpers import get_email_template
-from lp.services.mail.sendmail import (
-    format_address,
-    simple_sendmail,
-    )
 from lp.services.propertycache import cachedproperty
 from lp.services.webapp import (
     ApplicationMenu,
@@ -200,7 +194,6 @@
 from lp.services.webapp.batching import BatchNavigator
 from lp.services.webapp.breadcrumb import Breadcrumb
 from lp.services.webapp.interfaces import (
-    ILaunchBag,
     UnsafeFormGetSubmissionError,
     )
 from lp.services.webapp.menu import NavigationMenu
@@ -309,74 +302,6 @@
             # Launchpad is ok with all licenses used in this project.
             pass
 
-    def notifyCommercialMailingList(self):
-        """Notify user about Launchpad license rules."""
-        licenses = list(self.product.licenses)
-        needs_email = (
-            License.OTHER_PROPRIETARY in licenses
-            or License.OTHER_OPEN_SOURCE in licenses
-            or [License.DONT_KNOW] == licenses)
-        if not needs_email:
-            # The project has a recognized license.
-            return
-
-        def indent(text):
-            if text is None:
-                return None
-            text = '\n    '.join(line for line in text.split('\n'))
-            text = '    ' + text
-            return text
-
-        user = getUtility(ILaunchBag).user
-        user_address = format_address(
-            user.displayname, user.preferredemail.email)
-        from_address = format_address(
-            "Launchpad", config.canonical.noreply_from_address)
-        commercial_address = format_address(
-            'Commercial', '[e-mail]')
-        license_titles = '\n'.join(
-            license.title for license in self.product.licenses)
-        substitutions = dict(
-            user_browsername=user.displayname,
-            user_name=user.name,
-            product_name=self.product.name,
-            product_url=canonical_url(self.product),
-            product_summary=indent(self.product.summary),
-            license_titles=indent(license_titles),
-            license_info=indent(self.product.license_info))
-        # Email the user about license policy.
-        subject = (
-            "License information for %(product_name)s "
-            "in Launchpad" % substitutions)
-        template = get_email_template(
-            'product-other-license.txt', app='registry')
-        message = template % substitutions
-        simple_sendmail(
-            from_address, user_address,
-            subject, message, headers={'Reply-To': commercial_address})
-        # Inform that Launchpad recognized the license change.
-        self._addLicenseChangeToReviewWhiteboard()
-        self.request.response.addInfoNotification(_(
-            "Launchpad is free to use for software under approved "
-            "licenses. The Launchpad team will be in contact with "
-            "you soon."))
-
-    def _addLicenseChangeToReviewWhiteboard(self):
-        """Update the whiteboard for the reviewer's benefit."""
-        now = self._formatDate()
-        whiteboard = 'User notified of license policy on %s.' % now
-        naked_product = removeSecurityProxy(self.product)
-        if naked_product.reviewer_whiteboard is None:
-            naked_product.reviewer_whiteboard = whiteboard
-        else:
-            naked_product.reviewer_whiteboard += '\n' + whiteboard
-
-    def _formatDate(self, now=None):
-        """Return the date formatted for messages."""
-        if now is None:
-            now = datetime.now(tz=pytz.UTC)
-        return now.strftime('%Y-%m-%d')
-
 
 class ProductFacets(QuestionTargetFacetMixin, StandardLaunchpadFacets):
     """The links that will appear in the facet menu for an IProduct."""
@@ -1620,13 +1545,7 @@
 
     @action("Change", name='change')
     def change_action(self, action, data):
-        previous_licenses = self.context.licenses
         self.updateContextFromData(data)
-        # only send email the first time licenses are set
-        if len(previous_licenses) == 0:
-            # self.product is expected by notifyCommercialMailingList
-            self.product = self.context
-            self.notifyCommercialMailingList()
 
     @property
     def next_url(self):

=== modified file 'lib/lp/registry/browser/tests/test_product.py'
--- lib/lp/registry/browser/tests/test_product.py	2012-03-02 06:46:29 +0000
+++ lib/lp/registry/browser/tests/test_product.py	2012-03-12 18:17:24 +0000
@@ -5,14 +5,9 @@
 
 __metaclass__ = type
 
-import datetime
-
-import pytz
 from zope.component import getUtility
-from zope.security.proxy import removeSecurityProxy
 
 from lp.app.enums import ServiceUsage
-from lp.registry.browser.product import ProductLicenseMixin
 from lp.registry.interfaces.product import (
     IProductSet,
     License,
@@ -22,13 +17,11 @@
 from lp.testing import (
     BrowserTestCase,
     login_celebrity,
-    login_person,
     person_logged_in,
     TestCaseWithFactory,
     )
 from lp.testing.fixture import DemoMode
 from lp.testing.layers import DatabaseFunctionalLayer
-from lp.testing.mail_helpers import pop_notifications
 from lp.testing.pages import find_tag_by_id
 from lp.testing.service_usage_helpers import set_service_usage
 from lp.testing.views import (
@@ -37,86 +30,6 @@
     )
 
 
-class TestProductLicenseMixin(TestCaseWithFactory):
-
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        # Setup an a view that implements ProductLicenseMixin.
-        super(TestProductLicenseMixin, self).setUp()
-        self.registrant = self.factory.makePerson(
-            name='registrant', email='[e-mail]')
-        self.product = self.factory.makeProduct(
-            name='ball', owner=self.registrant)
-        self.view = create_view(self.product, '+edit')
-        self.view.product = self.product
-        login_person(self.registrant)
-
-    def verify_whiteboard(self):
-        # Verify that the review whiteboard was updated.
-        naked_product = removeSecurityProxy(self.product)
-        whiteboard, stamp = naked_product.reviewer_whiteboard.rsplit(' ', 1)
-        self.assertEqual(
-            'User notified of license policy on', whiteboard)
-
-    def verify_user_email(self, notification):
-        # Verify that the user was sent an email about the license change.
-        self.assertEqual(
-            'License information for ball in Launchpad',
-            notification['Subject'])
-        self.assertEqual(
-            'Registrant <[e-mail]>',
-            notification['To'])
-        self.assertEqual(
-            'Commercial <[e-mail]>',
-            notification['Reply-To'])
-
-    def test_ProductLicenseMixin_instance(self):
-        # The object under test is an instance of ProductLicenseMixin.
-        self.assertTrue(isinstance(self.view, ProductLicenseMixin))
-
-    def test_notifyCommercialMailingList_known_license(self):
-        # A known license does not generate an email.
-        self.product.licenses = [License.GNU_GPL_V2]
-        self.view.notifyCommercialMailingList()
-        self.assertEqual(0, len(pop_notifications()))
-
-    def test_notifyCommercialMailingList_other_dont_know(self):
-        # An Other/I don't know license sends one email.
-        self.product.licenses = [License.DONT_KNOW]
-        self.view.notifyCommercialMailingList()
-        self.verify_whiteboard()
-        notifications = pop_notifications()
-        self.assertEqual(1, len(notifications))
-        self.verify_user_email(notifications.pop())
-
-    def test_notifyCommercialMailingList_other_open_source(self):
-        # An Other/Open Source license sends one email.
-        self.product.licenses = [License.OTHER_OPEN_SOURCE]
-        self.product.license_info = 'http://www,boost.org/'
-        self.view.notifyCommercialMailingList()
-        self.verify_whiteboard()
-        notifications = pop_notifications()
-        self.assertEqual(1, len(notifications))
-        self.verify_user_email(notifications.pop())
-
-    def test_notifyCommercialMailingList_other_proprietary(self):
-        # An Other/Proprietary license sends one email.
-        self.product.licenses = [License.OTHER_PROPRIETARY]
-        self.product.license_info = 'All mine'
-        self.view.notifyCommercialMailingList()
-        self.verify_whiteboard()
-        notifications = pop_notifications()
-        self.assertEqual(1, len(notifications))
-        self.verify_user_email(notifications.pop())
-
-    def test__formatDate(self):
-        # Verify the date format.
-        now = datetime.datetime(2005, 6, 15, 0, 0, 0, 0, pytz.UTC)
-        result = self.view._formatDate(now)
-        self.assertEqual('2005-06-15', result)
-
-
 class TestProductConfiguration(TestCaseWithFactory):
     """Tests the configuration links and helpers."""
 

=== modified file 'lib/lp/registry/configure.zcml'
--- lib/lp/registry/configure.zcml	2012-02-24 07:17:43 +0000
+++ lib/lp/registry/configure.zcml	2012-03-12 18:17:24 +0000
@@ -1056,7 +1056,7 @@
     </class>
     <subscriber
         for="lp.registry.interfaces.product.IProduct zope.lifecycleevent.interfaces.IObjectModifiedEvent"
-        handler="lp.registry.subscribers.product_modified"/>
+        handler="lp.registry.subscribers.product_licenses_modified"/>
     <class
         class="lp.registry.model.mailinglist.MailingList">
         <allow

=== modified file 'lib/lp/registry/model/product.py'
--- lib/lp/registry/model/product.py	2012-03-12 11:02:48 +0000
+++ lib/lp/registry/model/product.py	2012-03-12 18:17:24 +0000
@@ -774,6 +774,22 @@
         for license in licenses.difference(old_licenses):
             ProductLicense(product=self, license=license)
         get_property_cache(self)._cached_licenses = tuple(sorted(licenses))
+        if (License.OTHER_PROPRIETARY in licenses
+            and self.commercial_subscription is None):
+            lp_janitor = getUtility(ILaunchpadCelebrities).janitor
+            now = datetime.datetime.now(pytz.UTC)
+            date_expires = now + datetime.timedelta(days=30)
+            sales_system_id = 'complimentary-30-day-%s' % now
+            whiteboard = (
+                "Complimentary 30 day subscription. -- Launchpad %s" %
+                now.date().isoformat())
+            subscription = CommercialSubscription(
+                product=self, date_starts=now, date_expires=date_expires,
+                registrant=lp_janitor, purchaser=lp_janitor,
+                sales_system_id=sales_system_id, whiteboard=whiteboard)
+            get_property_cache(self).commercial_subscription = subscription
+        # Do not use a snapshot because the past is unintersting.
+        notify(ObjectModifiedEvent(self, self, edited_fields=['licenses']))
 
     licenses = property(_getLicenses, _setLicenses)
 

=== modified file 'lib/lp/registry/subscribers.py'
--- lib/lp/registry/subscribers.py	2009-06-25 04:06:00 +0000
+++ lib/lp/registry/subscribers.py	2012-03-12 18:17:24 +0000
@@ -1,13 +1,112 @@
 # Copyright 2009 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
+"""Functions and classes that are subscribed to registry events."""
 
 __metaclass__ = type
 
 __all__ = [
-    'product_modified',
+    'product_licenses_modified',
     ]
 
-
-def product_modified(product, event):
-    pass
-
+from datetime import datetime
+
+import pytz
+
+from zope.security.proxy import removeSecurityProxy
+
+from lp.registry.interfaces.person import IPerson
+from lp.registry.interfaces.product import License
+from lp.services.config import config
+from lp.services.mail.helpers import get_email_template
+from lp.services.mail.sendmail import (
+    format_address,
+    simple_sendmail,
+    )
+from lp.services.webapp.publisher import canonical_url
+
+
+def product_licenses_modified(product, event):
+    """Send a notification if licenses changed and a license is special."""
+    licenses_changed = 'licenses' in event.edited_fields
+    needs_notification = LicenseNotification.needs_notification(product)
+    if licenses_changed and needs_notification:
+        user = IPerson(event.user)
+        notification = LicenseNotification(product, user)
+        notification.send()
+
+
+class LicenseNotification:
+    """Send notification about special licenses to the user."""
+
+    def __init__(self, product, user):
+        self.product = product
+        self.user = user
+
+    @staticmethod
+    def needs_notification(product):
+        licenses = list(product.licenses)
+        return (
+            License.OTHER_PROPRIETARY in licenses
+            or License.OTHER_OPEN_SOURCE in licenses
+            or [License.DONT_KNOW] == licenses)
+
+    def send(self):
+        """Send a message to the user about the product's license."""
+        if not self.needs_notification(self.product):
+            # The project has a common license.
+            return False
+        user_address = format_address(
+            self.user.displayname, self.user.preferredemail.email)
+        from_address = format_address(
+            "Launchpad", config.canonical.noreply_from_address)
+        commercial_address = format_address(
+            'Commercial', '[e-mail]')
+        license_titles = '\n'.join(
+            license.title for license in self.product.licenses)
+        substitutions = dict(
+            user_browsername=self.user.displayname,
+            user_name=self.user.name,
+            product_name=self.product.name,
+            product_url=canonical_url(self.product),
+            product_summary=self._indent(self.product.summary),
+            license_titles=self._indent(license_titles),
+            license_info=self._indent(self.product.license_info))
+        # Email the user about license policy.
+        subject = (
+            "License information for %(product_name)s "
+            "in Launchpad" % substitutions)
+        template = get_email_template(
+            'product-other-license.txt', app='registry')
+        message = template % substitutions
+        simple_sendmail(
+            from_address, user_address,
+            subject, message, headers={'Reply-To': commercial_address})
+        # Inform that Launchpad recognized the license change.
+        self._addLicenseChangeToReviewWhiteboard()
+        return True
+
+    @staticmethod
+    def _indent(text):
+        """Indent the text to be included in the message."""
+        if text is None:
+            return None
+        text = '\n    '.join(line for line in text.split('\n'))
+        text = '    ' + text
+        return text
+
+    @staticmethod
+    def _formatDate(now=None):
+        """Return the date formatted for messages."""
+        if now is None:
+            now = datetime.now(tz=pytz.UTC)
+        return now.strftime('%Y-%m-%d')
+
+    def _addLicenseChangeToReviewWhiteboard(self):
+        """Update the whiteboard for the reviewer's benefit."""
+        now = self._formatDate()
+        whiteboard = 'User notified of license policy on %s.' % now
+        naked_product = removeSecurityProxy(self.product)
+        if naked_product.reviewer_whiteboard is None:
+            naked_product.reviewer_whiteboard = whiteboard
+        else:
+            naked_product.reviewer_whiteboard += '\n' + whiteboard

=== modified file 'lib/lp/registry/tests/test_product.py'
--- lib/lp/registry/tests/test_product.py	2012-03-12 11:02:48 +0000
+++ lib/lp/registry/tests/test_product.py	2012-03-12 18:17:24 +0000
@@ -11,6 +11,7 @@
 from testtools.matchers import MatchesAll
 import transaction
 from zope.component import getUtility
+from zope.lifecycleevent.interfaces import IObjectModifiedEvent
 from zope.security.interfaces import Unauthorized
 from zope.security.proxy import removeSecurityProxy
 
@@ -20,6 +21,7 @@
     IHasIcon,
     IHasLogo,
     IHasMugshot,
+    ILaunchpadCelebrities,
     ILaunchpadUsage,
     IServiceUsage,
     )
@@ -38,6 +40,7 @@
     )
 from lp.registry.interfaces.product import (
     IProduct,
+    IProductSet,
     License,
     )
 from lp.registry.interfaces.series import SeriesStatus
@@ -55,6 +58,7 @@
     TestCaseWithFactory,
     WebServiceTestCase,
     )
+from lp.testing.event import TestEventListener
 from lp.testing.layers import (
     DatabaseFunctionalLayer,
     LaunchpadFunctionalLayer,
@@ -459,6 +463,19 @@
     """Test the rules of licenses and commercial subscriptions."""
 
     layer = DatabaseFunctionalLayer
+    event_listener = None
+
+    def setup_event_listener(self):
+        self.events = []
+        if self.event_listener is None:
+            self.event_listener = TestEventListener(
+                IProduct, IObjectModifiedEvent, self.on_event)
+        else:
+            self.event_listener._active = True
+        self.addCleanup(self.event_listener.unregister)
+
+    def on_event(self, thing, event):
+        self.events.append(event)
 
     def test_getLicenses(self):
         # License are assigned a list, but return a tuple.
@@ -472,10 +489,24 @@
         product = self.factory.makeProduct(licenses=[License.MIT])
         with celebrity_logged_in('registry_experts'):
             product.project_reviewed = True
+        self.setup_event_listener()
         with person_logged_in(product.owner):
             product.licenses = [License.MIT]
         with celebrity_logged_in('registry_experts'):
             self.assertIs(True, product.project_reviewed)
+        self.assertEqual([], self.events)
+
+    def test_setLicense(self):
+        # The project_reviewed property is not reset, if the new licenses
+        # are identical to the current licenses.
+        product = self.factory.makeProduct()
+        self.setup_event_listener()
+        with person_logged_in(product.owner):
+            product.licenses = [License.MIT]
+        self.assertEqual((License.MIT, ), product.licenses)
+        self.assertEqual(1, len(self.events))
+        self.assertEqual(product, self.events[0].object)
+        self.assertEqual(['licenses'], self.events[0].edited_fields)
 
     def test_setLicense_also_sets_reviewed(self):
         # The project_reviewed attribute it set to False if the licenses
@@ -514,6 +545,72 @@
             self.assertRaises(
                 ValueError, setattr, product, 'licenses', ['bogus'])
 
+    def test_setLicense_non_proprietary(self):
+        # Non-proprietary projects are not given a complimentary
+        # commercial subscription.
+        product = self.factory.makeProduct(licenses=[License.MIT])
+        self.assertIsNone(product.commercial_subscription)
+
+    def test_setLicense_proprietary_with_commercial_subscription(self):
+        # Proprietary projects with existing commercial subscriptions are not
+        # given a complimentary commercial subscription.
+        product = self.factory.makeProduct()
+        self.factory.makeCommercialSubscription(product)
+        with celebrity_logged_in('admin'):
+            product.commercial_subscription.sales_system_id = 'testing'
+            date_expires = product.commercial_subscription.date_expires
+        with person_logged_in(product.owner):
+            product.licenses = [License.OTHER_PROPRIETARY]
+        with celebrity_logged_in('admin'):
+            self.assertEqual(
+                'testing', product.commercial_subscription.sales_system_id)
+            self.assertEqual(
+                date_expires, product.commercial_subscription.date_expires)
+
+    def test_setLicense_proprietary_without_commercial_subscription(self):
+        # Proprietary projects without a commercial subscriptions are
+        # given a complimentary 30 day commercial subscription.
+        product = self.factory.makeProduct()
+        with person_logged_in(product.owner):
+            product.licenses = [License.OTHER_PROPRIETARY]
+        with celebrity_logged_in('admin'):
+            cs = product.commercial_subscription
+            self.assertIsNotNone(cs)
+            self.assertIn('complimentary-30-day', cs.sales_system_id)
+            now = datetime.datetime.now(pytz.UTC)
+            self.assertTrue(now >= cs.date_starts)
+            future_30_days = now + datetime.timedelta(days=30)
+            self.assertTrue(future_30_days >= cs.date_expires)
+            self.assertIn(
+                "Complimentary 30 day subscription. -- Launchpad",
+                cs.whiteboard)
+            lp_janitor = getUtility(ILaunchpadCelebrities).janitor
+            self.assertEqual(lp_janitor, cs.registrant)
+            self.assertEqual(lp_janitor, cs.purchaser)
+
+    def test_new_proprietary_has_commercial_subscription(self):
+        # New proprietary projects are given a complimentary 30 day
+        # commercial subscription.
+        owner = self.factory.makePerson()
+        with person_logged_in(owner):
+            product = getUtility(IProductSet).createProduct(
+                owner, 'fnord', 'Fnord', 'Fnord', 'test 1', 'test 2',
+                licenses=[License.OTHER_PROPRIETARY])
+        with celebrity_logged_in('admin'):
+            cs = product.commercial_subscription
+            self.assertIsNotNone(cs)
+            self.assertIn('complimentary-30-day', cs.sales_system_id)
+            now = datetime.datetime.now(pytz.UTC)
+            self.assertTrue(now >= cs.date_starts)
+            future_30_days = now + datetime.timedelta(days=30)
+            self.assertTrue(future_30_days >= cs.date_expires)
+            self.assertIn(
+                "Complimentary 30 day subscription. -- Launchpad",
+                cs.whiteboard)
+            lp_janitor = getUtility(ILaunchpadCelebrities).janitor
+            self.assertEqual(lp_janitor, cs.registrant)
+            self.assertEqual(lp_janitor, cs.purchaser)
+
 
 class ProductSnapshotTestCase(TestCaseWithFactory):
     """Test product snapshots.

=== added file 'lib/lp/registry/tests/test_subscribers.py'
--- lib/lp/registry/tests/test_subscribers.py	1970-01-01 00:00:00 +0000
+++ lib/lp/registry/tests/test_subscribers.py	2012-03-12 18:17:24 +0000
@@ -0,0 +1,152 @@
+# Copyright 2012 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test subscruber classes and functions."""
+
+__metaclass__ = type
+
+from datetime import datetime
+
+import pytz
+
+from zope.security.proxy import removeSecurityProxy
+from lazr.lifecycle.event import ObjectModifiedEvent
+
+from lp.registry.interfaces.product import License
+from lp.registry.subscribers import (
+    LicenseNotification,
+    product_licenses_modified,
+    )
+from lp.testing import (
+    login_person,
+    TestCaseWithFactory,
+    )
+from lp.testing.layers import DatabaseFunctionalLayer
+from lp.testing.mail_helpers import pop_notifications
+
+
+class ProductLicensesModifiedTestCase(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def make_product_event(self, licenses, edited_fields='licenses'):
+        product = self.factory.makeProduct(licenses=licenses)
+        pop_notifications()
+        login_person(product.owner)
+        event = ObjectModifiedEvent(
+            product, product, edited_fields, user=product.owner)
+        return product, event
+
+    def test_product_licenses_modified_licenses_not_edited(self):
+        product, event = self.make_product_event(
+            [License.OTHER_PROPRIETARY], edited_fields='_owner')
+        product_licenses_modified(product, event)
+        notifications = pop_notifications()
+        self.assertEqual(0, len(notifications))
+
+    def test_product_licenses_modified_licenses_common_license(self):
+        product, event = self.make_product_event([License.MIT])
+        product_licenses_modified(product, event)
+        notifications = pop_notifications()
+        self.assertEqual(0, len(notifications))
+
+    def test_product_licenses_modified_licenses_other_proprietary(self):
+        product, event = self.make_product_event([License.OTHER_PROPRIETARY])
+        product_licenses_modified(product, event)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+
+    def test_product_licenses_modified_licenses_other_open_source(self):
+        product, event = self.make_product_event([License.OTHER_OPEN_SOURCE])
+        product_licenses_modified(product, event)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+
+    def test_product_licenses_modified_licenses_other_dont_know(self):
+        product, event = self.make_product_event([License.DONT_KNOW])
+        product_licenses_modified(product, event)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+
+
+class LicenseNotificationTestCase(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def make_product_user(self, licenses):
+        # Setup an a view that implements ProductLicenseMixin.
+        super(LicenseNotificationTestCase, self).setUp()
+        user = self.factory.makePerson(
+            name='registrant', email='[e-mail]')
+        login_person(user)
+        product = self.factory.makeProduct(
+            name='ball', owner=user, licenses=licenses)
+        pop_notifications()
+        return product, user
+
+    def verify_whiteboard(self, product):
+        # Verify that the review whiteboard was updated.
+        naked_product = removeSecurityProxy(product)
+        entries = naked_product.reviewer_whiteboard.split('\n')
+        whiteboard, stamp = entries[-1].rsplit(' ', 1)
+        self.assertEqual(
+            'User notified of license policy on', whiteboard)
+
+    def verify_user_email(self, notification):
+        # Verify that the user was sent an email about the license change.
+        self.assertEqual(
+            'License information for ball in Launchpad',
+            notification['Subject'])
+        self.assertEqual(
+            'Registrant <[e-mail]>',
+            notification['To'])
+        self.assertEqual(
+            'Commercial <[e-mail]>',
+            notification['Reply-To'])
+
+    def test_notifyCommercialMailingList_known_license(self):
+        # A known license does not generate an email.
+        product, user = self.make_product_user([License.GNU_GPL_V2])
+        notification = LicenseNotification(product, user)
+        result = notification.send()
+        self.assertIs(False, result)
+        self.assertEqual(0, len(pop_notifications()))
+
+    def test_notifyCommercialMailingList_other_dont_know(self):
+        # An Other/I don't know license sends one email.
+        product, user = self.make_product_user([License.DONT_KNOW])
+        notification = LicenseNotification(product, user)
+        result = notification.send()
+        self.assertIs(True, result)
+        self.verify_whiteboard(product)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+        self.verify_user_email(notifications.pop())
+
+    def test_notifyCommercialMailingList_other_open_source(self):
+        # An Other/Open Source license sends one email.
+        product, user = self.make_product_user([License.OTHER_OPEN_SOURCE])
+        notification = LicenseNotification(product, user)
+        result = notification.send()
+        self.assertIs(True, result)
+        self.verify_whiteboard(product)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+        self.verify_user_email(notifications.pop())
+
+    def test_notifyCommercialMailingList_other_proprietary(self):
+        # An Other/Proprietary license sends one email.
+        product, user = self.make_product_user([License.OTHER_PROPRIETARY])
+        notification = LicenseNotification(product, user)
+        result = notification.send()
+        self.assertIs(True, result)
+        self.verify_whiteboard(product)
+        notifications = pop_notifications()
+        self.assertEqual(1, len(notifications))
+        self.verify_user_email(notifications.pop())
+
+    def test_formatDate(self):
+        # Verify the date format.
+        now = datetime(2005, 6, 15, 0, 0, 0, 0, pytz.UTC)
+        result = LicenseNotification._formatDate(now)
+        self.assertEqual('2005-06-15', result)

=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2012-03-07 00:23:37 +0000
+++ lib/lp/testing/factory.py	2012-03-12 18:17:24 +0000
@@ -967,17 +967,18 @@
             title = self.getUniqueString('title')
         if summary is None:
             summary = self.getUniqueString('summary')
-        product = getUtility(IProductSet).createProduct(
-            owner,
-            name,
-            displayname,
-            title,
-            summary,
-            self.getUniqueString('description'),
-            licenses=licenses,
-            project=project,
-            registrant=registrant,
-            icon=icon)
+        with person_logged_in(owner):
+            product = getUtility(IProductSet).createProduct(
+                owner,
+                name,
+                displayname,
+                title,
+                summary,
+                self.getUniqueString('description'),
+                licenses=licenses,
+                project=project,
+                registrant=registrant,
+                icon=icon)
         naked_product = removeSecurityProxy(product)
         if official_malone is not None:
             naked_product.official_malone = official_malone